Wrong typings on addRelationship and where?

[pedromtcosta]

I have the following snippet which works as expected for defining a model with a relationship to itself and then creating a node relating to an existing node:

const Blocks = ModelFactory({
  label: 'Block',
  schema: {
    hash: {
      type: 'string',
      required: true,
    },
    number: {
      type: 'number',
      required: true,
    }
  },
  primaryKeyField: 'hash',
}, neogma);

Blocks.addRelationships({
  Prev: {
    model: Blocks,
    direction: 'out',
    name: 'PREV',
  }
} as any);

async function main() {
  const block = await Blocks.createOne({
    hash: 'hash2',
    number: 2,
    Prev: {
      where: {
        params: {
          'hash': 'hash'
        }
      }
    } as any
  });

  console.log(block);
}

main();

The problem is that I had to add these two ugly as any casts, otherwise I get the following TypeScript errors respectively for each cast:

Argument of type '{ Prev: { model: NeogmaModel<Neo4jSupportedProperties, Object, Object, Object>; direction: string; name: string; }; }' is not assignable to parameter of type 'Partial<RelationshipsI<Object>>'.
  Object literal may only specify known properties, and 'Prev' does not exist in type 'Partial<RelationshipsI<Object>>'

Type '{ where: { params: { hash: string; }; }; }' is not assignable to type 'Neo4jSupportedTypes | undefined'.
  Object literal may only specify known properties, and 'where' does not exist in type 'Integer | Point<Integer> | Date<Integer> | Time<Integer> | LocalTime<Integer> | DateTime<Integer> | LocalDateTime<...> | Duration<...> | Neo4jSingleTypes[]'

is there a way to accomplish what I am doing without relying on these casts?

[pedromtcosta]

ok, that's embarrassing but 10 minutes afterwards I figured out the problem, I had to explicitly provide the generic parameters for ModelFactory:

type BlockProperties = {
  hash: string;
  number: number;
};

type BlockRelationships = {
  Prev: ModelRelatedNodesI<
    NeogmaModel<BlockProperties, Object, Object, Object>,
    NeogmaInstance<BlockProperties, BlockRelationships, Object>
  >;
};

const Blocks = ModelFactory<BlockProperties, BlockRelationships>({
  label: 'Block',
  schema: {
    hash: {
      type: 'string',
      required: true,
    },
    number: {
      type: 'number',
      required: true,
    }
  },
  primaryKeyField: 'hash',
}, neogma);

Blocks.addRelationships({
  Prev: {
    model: Blocks,
    direction: 'out',
    name: 'PREV',
  }
});

async function main() {
  const block = await Blocks.createOne({
    hash: 'hash2',
    number: 2,
    Prev: {
      where: {
        params: {
          'hash': 'hash'
        }
      }
    }
  });

  console.log(block);
}

main();

[themetalfleece]

Glad you figured it out :)
Unrelated to the type, you can also use the self value to indicate that the model refers to itself: https://themetalfleece.github.io/neogma/docs/Models/Defining-a-Model#relating-a-model-to-itself