[HELP] Type 'T' does not satisfy the constraint 'Dict'.

[ninjazoete]

I started using Neo4j driver from TypeScript and I have this problem:
Type 'T' does not satisfy the constraint 'Dict'. when I try to abstract away session usage within a generic function.

My goal is to have typed queries like here:
https://dev.to/adamcowley/using-typescript-with-neo4j-478c

I tried extending T with Dict but I am not able to see Dict outside of Neo4J modules.

Here is my function:

export async function executeCypherQueryOnSession<T>(action: (session: Session) => Promise<QueryResult<T>>
) {
  const session = driver.session();

  try {
    let result = action(session);
    session.close();

    return result;
  } catch (err) {
    throw Error('Error occured in executeCypherQueryOnSession: ${err}');
  }
}

I am a complete beginner in typescript / javascript and neo4J.
Can you please help me?

Thank you

Edit:
To clarify this is the usage:

return executeCypherQueryOnSession<ActorActedInMovie>(async (session) => {
            return await session.executeRead((tx) => { 
                return tx.run<ActorActedInMovie >(
                    "MATCH (actor: Actor {name: ${name}})-[acts:ACTS]-(movie: Movie) return movie ")
            })
        })

If i don't abstract away T and just pass the interface like in the article straight to tx.run it is accepted by neo4j API.

[bigmontz]

You can define Dict as:

type Dict<Key extends PropertyKey = PropertyKey, Value = any> = {
  [K in Key]: Value
}

And then change you method signature to:

export async function executeCypherQueryOnSession<T extends Dict>(action: (session: Session) => Promise<QueryResult<T>>

You probably want to update the implementation to close the session after consume the result like:

export async function executeCypherQueryOnSession<T extends Dict>(action: (session: Session) => Promise<QueryResult<T>> {
  const session = driver.session();

  try {
    return await action(session);
  } catch (err) {
    throw Error('Error occured in executeCypherQueryOnSession: ${err}');
  } finally {
    await session.close()
  }
}

However, if you would like to run only a single query, i recommend to use driver.executeQuery. See: #1006 and https://neo4j.com/docs/api/javascript-driver/5.10/class/lib6/driver.js~Driver.html#instance-method-executeQuery

[ninjazoete]

@bigmontz thank you for help!
I used the simplified approach and I can see it accepts any T which is good for me.

I wonder how is it in typescript that Dict is public and seen outside of modules but it cant be referenced and you have to define it again in your module? I am a mobile dev and in language like Swift if you have any type used in public interface it needs to be public and exported outside of "module".

[ninjazoete]

@bigmontz can I ask one more thing?

when I do

export interface UserAttendsEvents {
        user: Nodes.User;
        attends: Relationships.Attends;
        events: [Nodes.Event];
    }
    export async function userAttendedEvents(name: string) {
        const a = await currentDriver().executeQuery<UserAttendsEvents>("MATCH (user: User {name: \" Peter\"})-[attends:ATTENDS]-(events: Event) return events");
        
    }

a is now supposed to be UserAttendsEvents but on runtime it is just EagerResult and whatever I want to get from my UserAttendsEvents it crashes. What is the goal of having in executeQuery ? How would I get the real data from this?

Sorry to bother you again, just trying to understand and in documentation there is no example with <T>.

[bigmontz]

executeQuery is extensible to return different types using the resultTransformer config. By default, the configured transformer returns EagerResult<T>, where T is the record shape.

So, for you use case you have to:

const { records } = driver.executeQuery<EagerResult< UserAttendsEvents>>("MATCH....");

// or
const { records }: EagerResult<UserAttendsEvents> = driver.executeQuery("MATCH ...");

Documentation around EagerResult:
https://neo4j.com/docs/api/javascript-driver/5.10/class/lib6/result-eager.js~EagerResult.html

I know the typing get a bit more complicated then the existing in the run methods, but this was needed to give some flexibility to the method.

Some discussions around executeQuery can be found here: #1052

Btw, the Dict will be exported as RecordShape in the next release was released in 5.11.0.