grafeo-ogm 1.0.0

package/dist/cjs/generator/type-emitters/select-fields-emitter.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSelectFieldTypes = emitSelectFieldTypes;
+const helpers_1 = require("./helpers");
+/**
+ * Emits `SelectFields` types for every node, interface, and edge-properties
+ * type in the schema. These types describe which fields can be selected in
+ * the type-safe `select` API.
+ */
+function emitSelectFieldTypes(schema) {
+    const blocks = [];
+    // Edge SelectFields — emitted first so node SelectFields can reference them
+    const edgeSelectBlocks = emitEdgeSelectFields(schema);
+    if (edgeSelectBlocks.length > 0)
+        blocks.push(...edgeSelectBlocks);
+    // Node SelectFields (sorted alphabetically)
+    const sortedNodes = [...schema.nodes.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, node] of sortedNodes)
+        blocks.push(emitNodeSelectFields(node, schema));
+    // Interface SelectFields (sorted alphabetically)
+    const sortedInterfaces = [...schema.interfaces.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, iface] of sortedInterfaces)
+        blocks.push(emitInterfaceSelectFields(iface, schema));
+    // Union SelectFields (type alias of member SelectFields)
+    const sortedUnions = [...(schema.unions?.entries() ?? [])].sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, members] of sortedUnions) {
+        const memberFields = members.map((m) => `${m}SelectFields`).join(' | ');
+        blocks.push(`export type ${name}SelectFields = ${memberFields};`);
+    }
+    return blocks.join('\n\n');
+}
+// ---------------------------------------------------------------------------
+// Node SelectFields
+// ---------------------------------------------------------------------------
+function emitNodeSelectFields(node, schema) {
+    const members = [];
+    // Scalar / enum fields
+    for (const [, prop] of node.properties) {
+        if (prop.isCypher)
+            continue;
+        members.push(`  ${prop.name}?: boolean;`);
+    }
+    // Relationship fields
+    for (const [, rel] of node.relationships)
+        members.push(emitRelationshipField(rel));
+    // Connection fields
+    for (const [, rel] of node.relationships)
+        members.push(emitConnectionField(node.typeName, rel, schema));
+    return `export type ${node.typeName}SelectFields = {\n${members.join('\n')}\n};`;
+}
+// ---------------------------------------------------------------------------
+// Interface SelectFields
+// ---------------------------------------------------------------------------
+function emitInterfaceSelectFields(iface, schema) {
+    const members = [];
+    // Scalar / enum fields
+    for (const [, prop] of iface.properties) {
+        if (prop.isCypher)
+            continue;
+        members.push(`  ${prop.name}?: boolean;`);
+    }
+    // Relationship fields
+    for (const [, rel] of iface.relationships)
+        members.push(emitRelationshipField(rel));
+    // Connection fields — interfaces can also expose connections
+    for (const [, rel] of iface.relationships)
+        members.push(emitConnectionField(iface.name, rel, schema));
+    return `export type ${iface.name}SelectFields = {\n${members.join('\n')}\n};`;
+}
+// ---------------------------------------------------------------------------
+// Edge SelectFields (for relationships with properties)
+// ---------------------------------------------------------------------------
+function emitEdgeSelectFields(schema) {
+    const blocks = [];
+    const emittedEdges = new Set();
+    // Gather all relationship definitions that carry edge properties
+    const allNodes = [...schema.nodes.values()];
+    for (const node of allNodes)
+        for (const [, rel] of node.relationships) {
+            if (!rel.properties)
+                continue;
+            const edgeTypeName = buildEdgeSelectFieldsName(node.typeName, rel);
+            if (emittedEdges.has(edgeTypeName))
+                continue;
+            emittedEdges.add(edgeTypeName);
+            const propsType = schema.relationshipProperties.get(rel.properties);
+            if (!propsType)
+                continue;
+            const members = buildScalarMembers(propsType.properties);
+            blocks.push(`export type ${edgeTypeName} = {\n${members.join('\n')}\n};`);
+        }
+    // Sort for deterministic output
+    blocks.sort();
+    return blocks;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Emits a single relationship field entry (non-connection). */
+function emitRelationshipField(rel) {
+    return `  ${rel.fieldName}?: boolean | { where?: ${rel.target}Where; select?: ${rel.target}SelectFields };`;
+}
+/**
+ * Emits a single connection field entry.
+ *
+ * Pattern:
+ * ```
+ * drugsConnection?: boolean | {
+ *   where?: ChartDrugsConnectionWhere;
+ *   select: {
+ *     edges?: boolean | {
+ *       node?: boolean | { select: DrugSelectFields };
+ *       properties?: boolean | { select: ChartDrugsEdgeSelectFields };
+ *     };
+ *   };
+ * };
+ * ```
+ */
+function emitConnectionField(ownerTypeName, rel, schema) {
+    const connFieldName = `${rel.fieldName}Connection`;
+    const connWhereName = `${ownerTypeName}${(0, helpers_1.toPascalCase)(rel.fieldName)}ConnectionWhere`;
+    const targetSelect = `${rel.target}SelectFields`;
+    // Build edge inner type
+    const edgeMembers = [
+        `        node?: boolean | { select: ${targetSelect} };`,
+    ];
+    // Only include properties if the relationship carries edge properties
+    if (rel.properties) {
+        const propsType = schema.relationshipProperties.get(rel.properties);
+        if (propsType) {
+            const edgeSelectName = buildEdgeSelectFieldsName(ownerTypeName, rel);
+            edgeMembers.push(`        properties?: boolean | { select: ${edgeSelectName} };`);
+        }
+    }
+    const lines = [
+        `  ${connFieldName}?: boolean | {`,
+        `    where?: ${connWhereName};`,
+        `    select: {`,
+        `      edges?: boolean | {`,
+        ...edgeMembers,
+        `      };`,
+        `    };`,
+        `  };`,
+    ];
+    return lines.join('\n');
+}
+/**
+ * Builds the name for an edge SelectFields type.
+ *
+ * Convention: `<OwnerType><PascalFieldName>EdgeSelectFields`
+ * Example: `ChartDrugsEdgeSelectFields`
+ */
+function buildEdgeSelectFieldsName(ownerTypeName, rel) {
+    return `${ownerTypeName}${(0, helpers_1.toPascalCase)(rel.fieldName)}EdgeSelectFields`;
+}
+/**
+ * Builds `fieldName?: boolean;` members for a set of scalar properties,
+ * skipping @cypher fields.
+ */
+function buildScalarMembers(properties) {
+    const members = [];
+    for (const [, prop] of properties) {
+        if (prop.isCypher)
+            continue;
+        members.push(`  ${prop.name}?: boolean;`);
+    }
+    return members;
+}
+//# sourceMappingURL=select-fields-emitter.js.map

package/dist/cjs/generator/type-emitters/select-fields-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-fields-emitter.js","sourceRoot":"","sources":["../../../../src/generator/type-emitters/select-fields-emitter.ts"],"names":[],"mappings":";;AAcA,oDAkCC;AAzCD,uCAAyC;AAEzC;;;;GAIG;AACH,SAAgB,oBAAoB,CAAC,MAAsB;IACzD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,4EAA4E;IAC5E,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACtD,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,CAAC;IAElE,4CAA4C;IAC5C,MAAM,WAAW,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAChE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CACnB,CAAC;IAEF,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,WAAW;QAChC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAElD,iDAAiD;IACjD,MAAM,gBAAgB,GAAG,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC1E,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CACnB,CAAC;IAEF,KAAK,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,gBAAgB;QACtC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAExD,yDAAyD;IACzD,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC3E,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CACnB,CAAC;IAEF,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,YAAY,EAAE,CAAC;QAC3C,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxE,MAAM,CAAC,IAAI,CAAC,eAAe,IAAI,kBAAkB,YAAY,GAAG,CAAC,CAAC;IACpE,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC7B,CAAC;AAED,8EAA8E;AAC9E,oBAAoB;AACpB,8EAA8E;AAE9E,SAAS,oBAAoB,CAC3B,IAAoB,EACpB,MAAsB;IAEtB,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,uBAAuB;IACvB,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACvC,IAAI,IAAI,CAAC,QAAQ;YAAE,SAAS;QAC5B,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED,sBAAsB;IACtB,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa;QACtC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC;IAE3C,oBAAoB;IACpB,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa;QACtC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;IAEhE,OAAO,eAAe,IAAI,CAAC,QAAQ,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;AACnF,CAAC;AAED,8EAA8E;AAC9E,yBAAyB;AACzB,8EAA8E;AAE9E,SAAS,yBAAyB,CAChC,KAA0B,EAC1B,MAAsB;IAEtB,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,uBAAuB;IACvB,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QACxC,IAAI,IAAI,CAAC,QAAQ;YAAE,SAAS;QAC5B,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED,sBAAsB;IACtB,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,CAAC,aAAa;QACvC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC;IAE3C,6DAA6D;IAC7D,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,CAAC,aAAa;QACvC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;IAE7D,OAAO,eAAe,KAAK,CAAC,IAAI,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;AAChF,CAAC;AAED,8EAA8E;AAC9E,wDAAwD;AACxD,8EAA8E;AAE9E,SAAS,oBAAoB,CAAC,MAAsB;IAClD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEvC,iEAAiE;IACjE,MAAM,QAAQ,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAE5C,KAAK,MAAM,IAAI,IAAI,QAAQ;QACzB,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACzC,IAAI,CAAC,GAAG,CAAC,UAAU;gBAAE,SAAS;YAE9B,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YACnE,IAAI,YAAY,CAAC,GAAG,CAAC,YAAY,CAAC;gBAAE,SAAS;YAC7C,YAAY,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAE/B,MAAM,SAAS,GAAG,MAAM,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACpE,IAAI,CAAC,SAAS;gBAAE,SAAS;YAEzB,MAAM,OAAO,GAAG,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YACzD,MAAM,CAAC,IAAI,CAAC,eAAe,YAAY,SAAS,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5E,CAAC;IAEH,gCAAgC;IAChC,MAAM,CAAC,IAAI,EAAE,CAAC;IACd,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E,gEAAgE;AAChE,SAAS,qBAAqB,CAAC,GAA2B;IACxD,OAAO,KAAK,GAAG,CAAC,SAAS,0BAA0B,GAAG,CAAC,MAAM,mBAAmB,GAAG,CAAC,MAAM,iBAAiB,CAAC;AAC9G,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAS,mBAAmB,CAC1B,aAAqB,EACrB,GAA2B,EAC3B,MAAsB;IAEtB,MAAM,aAAa,GAAG,GAAG,GAAG,CAAC,SAAS,YAAY,CAAC;IACnD,MAAM,aAAa,GAAG,GAAG,aAAa,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,SAAS,CAAC,iBAAiB,CAAC;IACtF,MAAM,YAAY,GAAG,GAAG,GAAG,CAAC,MAAM,cAAc,CAAC;IAEjD,wBAAwB;IACxB,MAAM,WAAW,GAAa;QAC5B,sCAAsC,YAAY,KAAK;KACxD,CAAC;IAEF,sEAAsE;IACtE,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;QACnB,MAAM,SAAS,GAAG,MAAM,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACpE,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,cAAc,GAAG,yBAAyB,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;YACrE,WAAW,CAAC,IAAI,CACd,4CAA4C,cAAc,KAAK,CAChE,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG;QACZ,KAAK,aAAa,gBAAgB;QAClC,eAAe,aAAa,GAAG;QAC/B,eAAe;QACf,2BAA2B;QAC3B,GAAG,WAAW;QACd,UAAU;QACV,QAAQ;QACR,MAAM;KACP,CAAC;IAEF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,SAAS,yBAAyB,CAChC,aAAqB,EACrB,GAA2B;IAE3B,OAAO,GAAG,aAAa,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,SAAS,CAAC,kBAAkB,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,SAAS,kBAAkB,CACzB,UAA2C;IAE3C,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,UAAU,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,QAAQ;YAAE,SAAS;QAC5B,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/cjs/generator/type-emitters/select-result-emitter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Emits the schema-independent `SelectFields` base type and `SelectResult`
+ * utility type that infers return shapes from a `select` object.
+ *
+ * These types are emitted once per generated file and do not depend on
+ * the parsed schema.
+ */
+export declare function emitSelectResultType(): string;
+//# sourceMappingURL=select-result-emitter.d.ts.map

package/dist/cjs/generator/type-emitters/select-result-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-result-emitter.d.ts","sourceRoot":"","sources":["../../../../src/generator/type-emitters/select-result-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAiD7C"}

package/dist/cjs/generator/type-emitters/select-result-emitter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSelectResultType = emitSelectResultType;
+/**
+ * Emits the schema-independent `SelectFields` base type and `SelectResult`
+ * utility type that infers return shapes from a `select` object.
+ *
+ * These types are emitted once per generated file and do not depend on
+ * the parsed schema.
+ */
+function emitSelectResultType() {
+    return `export type SelectFields = Record<
+  string,
+  boolean | { select: SelectFields } | { where?: unknown; select: unknown }
+>;
+
+export type SelectResult<T, S extends SelectFields> = {
+  [K in keyof S & keyof T]: S[K] extends true
+    ? T[K]
+    : S[K] extends { select: infer NestedS }
+      ? T[K] extends Array<infer U>
+        ? NestedS extends SelectFields
+          ? Array<SelectResult<U, NestedS>>
+          : T[K]
+        : T[K] extends infer U | null | undefined
+          ? NestedS extends SelectFields
+            ? SelectResult<NonNullable<U>, NestedS> | null
+            : T[K]
+          : T[K]
+      : never;
+};
+
+type MutationInfoFields = {
+  nodesCreated: number;
+  nodesDeleted: number;
+  relationshipsCreated: number;
+  relationshipsDeleted: number;
+};
+
+export type MutationInfoResult<S extends Record<string, boolean>> = {
+  [K in keyof S & keyof MutationInfoFields]: MutationInfoFields[K];
+};
+
+export type MutationSelectResult<
+  T,
+  TPluralKey extends string,
+  S extends Record<string, unknown>,
+> =
+  ('info' extends keyof S
+    ? S['info'] extends Record<string, boolean>
+      ? { info: MutationInfoResult<S['info']> }
+      : {}
+    : {})
+  &
+  (TPluralKey extends keyof S
+    ? S[TPluralKey] extends SelectFields
+      ? { [K in TPluralKey]: Array<SelectResult<T, S[TPluralKey] & SelectFields>> }
+      : {}
+    : {});`;
+}
+//# sourceMappingURL=select-result-emitter.js.map

package/dist/cjs/generator/type-emitters/select-result-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-result-emitter.js","sourceRoot":"","sources":["../../../../src/generator/type-emitters/select-result-emitter.ts"],"names":[],"mappings":";;AAOA,oDAiDC;AAxDD;;;;;;GAMG;AACH,SAAgB,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+CE,CAAC;AACZ,CAAC"}

package/dist/cjs/generator/type-emitters/sort-options-emitter.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaMetadata } from '../../schema/types';
+/**
+ * For each node in the schema, emits a `<Node>Sort` type (with one optional
+ * `SortDirection` field per scalar property) and a `<Node>Options` type that
+ * exposes `limit`, `offset`, and `sort`.
+ */
+export declare function emitSortOptions(schema: SchemaMetadata): string;
+//# sourceMappingURL=sort-options-emitter.d.ts.map

package/dist/cjs/generator/type-emitters/sort-options-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-options-emitter.d.ts","sourceRoot":"","sources":["../../../../src/generator/type-emitters/sort-options-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,oBAAoB,CAAC;AAEzE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAW9D"}

package/dist/cjs/generator/type-emitters/sort-options-emitter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSortOptions = emitSortOptions;
+/**
+ * For each node in the schema, emits a `<Node>Sort` type (with one optional
+ * `SortDirection` field per scalar property) and a `<Node>Options` type that
+ * exposes `limit`, `offset`, and `sort`.
+ */
+function emitSortOptions(schema) {
+    const blocks = [];
+    // Process nodes in alphabetical order
+    const sortedNodes = [...schema.nodes.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, node] of sortedNodes)
+        blocks.push(emitNodeSortAndOptions(node));
+    return blocks.join('\n\n');
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function emitNodeSortAndOptions(node) {
+    const sortFields = getSortableProperties(node);
+    const sortMembers = sortFields
+        .map((name) => `  ${name}?: InputMaybe<SortDirection>;`)
+        .join('\n');
+    const sortType = `export type ${node.typeName}Sort = {\n${sortMembers}\n};`;
+    const optionsType = `export type ${node.typeName}Options = {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  sort?: InputMaybe<Array<${node.typeName}Sort>>;
+};`;
+    return `${sortType}\n\n${optionsType}`;
+}
+/**
+ * Returns the names of all scalar (non-relationship, non-cypher) properties
+ * on a node, preserving the insertion order of the properties map.
+ */
+function getSortableProperties(node) {
+    const names = [];
+    for (const [name, prop] of node.properties) {
+        // Skip @cypher fields — they are computed and not stored
+        if (prop.isCypher)
+            continue;
+        names.push(name);
+    }
+    return names;
+}
+//# sourceMappingURL=sort-options-emitter.js.map

package/dist/cjs/generator/type-emitters/sort-options-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-options-emitter.js","sourceRoot":"","sources":["../../../../src/generator/type-emitters/sort-options-emitter.ts"],"names":[],"mappings":";;AAOA,0CAWC;AAhBD;;;;GAIG;AACH,SAAgB,eAAe,CAAC,MAAsB;IACpD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,sCAAsC;IACtC,MAAM,WAAW,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAChE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CACnB,CAAC;IAEF,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,WAAW;QAAE,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9E,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC7B,CAAC;AAED,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E,SAAS,sBAAsB,CAAC,IAAoB;IAClD,MAAM,UAAU,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAE/C,MAAM,WAAW,GAAG,UAAU;SAC3B,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,+BAA+B,CAAC;SACvD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,MAAM,QAAQ,GAAG,eAAe,IAAI,CAAC,QAAQ,aAAa,WAAW,MAAM,CAAC;IAE5E,MAAM,WAAW,GAAG,eAAe,IAAI,CAAC,QAAQ;;;4BAGtB,IAAI,CAAC,QAAQ;GACtC,CAAC;IAEF,OAAO,GAAG,QAAQ,OAAO,WAAW,EAAE,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,SAAS,qBAAqB,CAAC,IAAoB;IACjD,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QAC3C,yDAAyD;QACzD,IAAI,IAAI,CAAC,QAAQ;YAAE,SAAS;QAE5B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/cjs/generator/type-emitters/utility-types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Emits the static utility types that appear at the top of every generated
+ * `ogm-types.ts` file.  These types are schema-independent.
+ */
+export declare function emitHeader(config?: {
+    header?: string;
+}, packageName?: string): string;
+export declare function emitImports(packageName?: string): string;
+export declare function emitUtilityTypes(): string;
+//# sourceMappingURL=utility-types.d.ts.map

package/dist/cjs/generator/type-emitters/utility-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.d.ts","sourceRoot":"","sources":["../../../../src/generator/type-emitters/utility-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAgB,UAAU,CACxB,MAAM,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5B,WAAW,SAAe,GACzB,MAAM,CASR;AAMD,wBAAgB,WAAW,CAAC,WAAW,SAAe,GAAG,MAAM,CAK9D;AAMD,wBAAgB,gBAAgB,IAAI,MAAM,CA0DzC"}

package/dist/cjs/generator/type-emitters/utility-types.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Emits the static utility types that appear at the top of every generated
+ * `ogm-types.ts` file.  These types are schema-independent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitHeader = emitHeader;
+exports.emitImports = emitImports;
+exports.emitUtilityTypes = emitUtilityTypes;
+// ---------------------------------------------------------------------------
+// Header
+// ---------------------------------------------------------------------------
+function emitHeader(config, packageName = 'grafeo-ogm') {
+    const lines = [
+        '// AUTO-GENERATED FILE — DO NOT EDIT',
+        `// Generated by ${packageName} generateTypes()`,
+    ];
+    if (config?.header)
+        lines.push(config.header);
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------
+function emitImports(packageName = 'grafeo-ogm') {
+    return [
+        'import type { SelectionSetNode, DocumentNode } from "graphql";',
+        `import type { Model, ModelInterface, InterfaceModelInterface } from "${packageName}";`,
+    ].join('\n');
+}
+// ---------------------------------------------------------------------------
+// Utility types (copied verbatim from the Neo4j OGM codegen output)
+// ---------------------------------------------------------------------------
+function emitUtilityTypes() {
+    return `export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = {
+  [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<
+  T extends { [key: string]: unknown },
+  K extends keyof T
+> = { [_ in K]?: never };
+export type Incremental<T> =
+  | T
+  | {
+      [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+    };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  /** The \`ID\` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as \`"4"\`) or integer (such as \`4\`) input value will be accepted as an ID. */
+  ID: { input: string; output: string };
+  /** The \`String\` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text. */
+  String: { input: string; output: string };
+  /** The \`Boolean\` scalar type represents \`true\` or \`false\`. */
+  Boolean: { input: boolean; output: boolean };
+  /** The \`Int\` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. */
+  Int: { input: number; output: number };
+  /** The \`Float\` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). */
+  Float: { input: number; output: number };
+  /** A date and time, represented as an ISO-8601 string */
+  DateTime: { input: any; output: any };
+  /** A 64-bit integer, represented as a string to avoid precision loss */
+  BigInt: { input: string; output: string };
+  /** A date without time, represented as an ISO-8601 date string (e.g. "2024-01-15") */
+  Date: { input: string; output: string };
+  /** A time with UTC offset, represented as an ISO-8601 time string (e.g. "12:30:00Z") */
+  Time: { input: string; output: string };
+  /** A local time without timezone, represented as an ISO-8601 time string (e.g. "12:30:00") */
+  LocalTime: { input: string; output: string };
+  /** A local date and time without timezone, represented as an ISO-8601 string */
+  LocalDateTime: { input: string; output: string };
+  /** An ISO 8601 duration (e.g. "P1Y2M3DT4H5M6S") */
+  Duration: { input: string; output: string };
+  /** A geographic point (WGS 84). Input accepts latitude/longitude; output uses x (longitude), y (latitude) from the driver */
+  Point: {
+    input: { latitude: number; longitude: number; height?: number; srid?: number };
+    output: { x: number; y: number; z?: number; srid: number };
+  };
+  /** A cartesian point with x, y, optional z coordinates, and SRID */
+  CartesianPoint: {
+    input: { x: number; y: number; z?: number; srid?: number };
+    output: { x: number; y: number; z?: number; srid: number };
+  };
+};`;
+}
+//# sourceMappingURL=utility-types.js.map

package/dist/cjs/generator/type-emitters/utility-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.js","sourceRoot":"","sources":["../../../../src/generator/type-emitters/utility-types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAMH,gCAYC;AAMD,kCAKC;AAMD,4CA0DC;AA3FD,8EAA8E;AAC9E,SAAS;AACT,8EAA8E;AAE9E,SAAgB,UAAU,CACxB,MAA4B,EAC5B,WAAW,GAAG,YAAY;IAE1B,MAAM,KAAK,GAAG;QACZ,sCAAsC;QACtC,mBAAmB,WAAW,kBAAkB;KACjD,CAAC;IAEF,IAAI,MAAM,EAAE,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAE9C,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E,SAAgB,WAAW,CAAC,WAAW,GAAG,YAAY;IACpD,OAAO;QACL,gEAAgE;QAChE,wEAAwE,WAAW,IAAI;KACxF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,8EAA8E;AAC9E,oEAAoE;AACpE,8EAA8E;AAE9E,SAAgB,gBAAgB;IAC9B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDN,CAAC;AACJ,CAAC"}

package/dist/cjs/generator/type-emitters/where-emitter.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaMetadata } from '../../schema/types';
+export interface WhereEmitterConfig {
+    /** When `false`, omits `_MATCHES` for String fields. Defaults to `true`. */
+    stringMatchesFilter?: boolean;
+}
+/**
+ * Emits `{TypeName}Where` types for every node and interface in the schema.
+ *
+ * Each Where type contains:
+ * 1. Scalar operator fields (per scalar property)
+ * 2. Relationship operator fields (per relationship)
+ * 3. Logical operators (OR, AND, NOT)
+ */
+export declare function emitWhereTypes(schema: SchemaMetadata, config?: WhereEmitterConfig): string;
+//# sourceMappingURL=where-emitter.d.ts.map

package/dist/cjs/generator/type-emitters/where-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"where-emitter.d.ts","sourceRoot":"","sources":["../../../../src/generator/type-emitters/where-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAIf,MAAM,oBAAoB,CAAC;AAO5B,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EACtB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,MAAM,CA8DR"}

package/dist/cjs/generator/type-emitters/where-emitter.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitWhereTypes = emitWhereTypes;
+const helpers_1 = require("./helpers");
+/**
+ * Emits `{TypeName}Where` types for every node and interface in the schema.
+ *
+ * Each Where type contains:
+ * 1. Scalar operator fields (per scalar property)
+ * 2. Relationship operator fields (per relationship)
+ * 3. Logical operators (OR, AND, NOT)
+ */
+function emitWhereTypes(schema, config) {
+    const blocks = [];
+    const enableMatches = config?.stringMatchesFilter !== false;
+    // Node Where types (sorted alphabetically)
+    const sortedNodes = [...schema.nodes.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, node] of sortedNodes)
+        blocks.push(emitWhereType(node.typeName, node.properties, node.relationships, schema, enableMatches, node));
+    // Interface Where types (sorted alphabetically)
+    const sortedInterfaces = [...schema.interfaces.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, iface] of sortedInterfaces)
+        blocks.push(emitWhereType(iface.name, iface.properties, iface.relationships, schema, enableMatches));
+    // Relationship-property Where types (sorted alphabetically)
+    const sortedRelProps = [...schema.relationshipProperties.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [, relProp] of sortedRelProps)
+        blocks.push(emitWhereType(relProp.typeName, relProp.properties, new Map(), schema, enableMatches));
+    // Union Where types (per-member keyed)
+    const sortedUnions = [...(schema.unions?.entries() ?? [])].sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, members] of sortedUnions)
+        blocks.push(emitUnionWhereType(name, members));
+    return blocks.join('\n\n');
+}
+// ---------------------------------------------------------------------------
+// Core emitter
+// ---------------------------------------------------------------------------
+function emitWhereType(typeName, properties, relationships, schema, enableMatches, nodeDef) {
+    const lines = [];
+    // 1. Scalar operator fields (including @cypher fields with scalar return types)
+    for (const [, prop] of properties) {
+        // Skip @cypher fields that return node/interface types (not scalars)
+        if (prop.isCypher &&
+            !(0, helpers_1.isBuiltInScalar)(prop.type) &&
+            !schema.enums.has(prop.type))
+            continue;
+        lines.push(...emitScalarOperators(prop, schema, enableMatches));
+    }
+    // 2. Logical operators (before relationships, matching reference output)
+    lines.push(`  OR?: InputMaybe<Array<${typeName}Where>>;`);
+    lines.push(`  AND?: InputMaybe<Array<${typeName}Where>>;`);
+    lines.push(`  NOT?: InputMaybe<${typeName}Where>;`);
+    // 3. Relationship operator fields
+    for (const [, rel] of relationships)
+        lines.push(...emitRelationshipOperators(typeName, rel, schema, nodeDef));
+    return `export type ${typeName}Where = {\n${lines.join('\n')}\n};`;
+}
+/** Temporal types that support comparison operators (LT, LTE, GT, GTE) */
+const TEMPORAL_TYPES = new Set([
+    'DateTime',
+    'Date',
+    'Time',
+    'LocalTime',
+    'LocalDateTime',
+    'Duration',
+]);
+/** Spatial types that only support equality and IN operators */
+const SPATIAL_TYPES = new Set(['Point', 'CartesianPoint']);
+function classifyType(typeName, enums) {
+    if (typeName === 'Boolean')
+        return 'boolean';
+    if (typeName === 'ID' || typeName === 'String')
+        return 'string-like';
+    if (typeName === 'Int' || typeName === 'Float' || typeName === 'BigInt')
+        return 'numeric-like';
+    if (TEMPORAL_TYPES.has(typeName))
+        return 'numeric-like';
+    if (SPATIAL_TYPES.has(typeName))
+        return 'spatial';
+    if (enums.has(typeName))
+        return 'enum';
+    // Default to string-like for unknown scalars
+    return 'string-like';
+}
+function scalarInputType(typeName, enums) {
+    if ((0, helpers_1.isBuiltInScalar)(typeName))
+        return `Scalars["${typeName}"]["input"]`;
+    if (enums.has(typeName))
+        return typeName;
+    return `Scalars["${typeName}"]["input"]`;
+}
+function emitScalarOperators(prop, schema, enableMatches) {
+    const lines = [];
+    const { name, type, required } = prop;
+    const category = classifyType(type, schema.enums);
+    const inputType = scalarInputType(type, schema.enums);
+    const wrap = (inner) => `InputMaybe<${inner}>`;
+    // Exact match
+    lines.push(`  ${name}?: ${wrap(inputType)};`);
+    // _NOT
+    lines.push(`  ${name}_NOT?: ${wrap(inputType)};`);
+    if (category === 'boolean')
+        // Boolean only has exact + _NOT
+        return lines;
+    // _IN / _NOT_IN (all non-boolean types)
+    const arrayInner = required ? inputType : `InputMaybe<${inputType}>`;
+    lines.push(`  ${name}_IN?: ${wrap(`Array<${arrayInner}>`)};`);
+    lines.push(`  ${name}_NOT_IN?: ${wrap(`Array<${arrayInner}>`)};`);
+    // Category-specific operators
+    switch (category) {
+        case 'string-like':
+            lines.push(`  ${name}_CONTAINS?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_STARTS_WITH?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_ENDS_WITH?: ${wrap(inputType)};`);
+            // _MATCHES only for String (not ID), and only if enabled
+            if (type === 'String' && enableMatches)
+                lines.push(`  ${name}_MATCHES?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_NOT_CONTAINS?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_NOT_STARTS_WITH?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_NOT_ENDS_WITH?: ${wrap(inputType)};`);
+            break;
+        case 'numeric-like':
+            lines.push(`  ${name}_LT?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_LTE?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_GT?: ${wrap(inputType)};`);
+            lines.push(`  ${name}_GTE?: ${wrap(inputType)};`);
+            break;
+        case 'enum':
+            // Enum has exact, _NOT, _IN, _NOT_IN — already emitted above
+            break;
+        case 'spatial':
+            // Spatial types only support exact, _NOT, _IN, _NOT_IN — already emitted above
+            break;
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Relationship operator generation
+// ---------------------------------------------------------------------------
+function emitRelationshipOperators(parentType, rel, schema, nodeDef) {
+    const lines = [];
+    const { fieldName, target, isArray } = rel;
+    const pascalField = (0, helpers_1.toPascalCase)(fieldName);
+    // For relationships inherited from an interface (@declareRelationship),
+    // use the interface-level ConnectionWhere type name
+    let connectionWhereName = `${parentType}${pascalField}ConnectionWhere`;
+    if (schema && nodeDef)
+        for (const ifaceName of nodeDef.implementsInterfaces) {
+            const iface = schema.interfaces.get(ifaceName);
+            if (iface?.relationships.has(fieldName)) {
+                connectionWhereName = `${ifaceName}${pascalField}ConnectionWhere`;
+                break;
+            }
+        }
+    // Aggregate filter operator
+    const aggInputName = `${parentType}${pascalField}AggregateInput`;
+    lines.push(`  ${fieldName}Aggregate?: InputMaybe<${aggInputName}>;`);
+    if (isArray) {
+        // Array relationship: full set of operators
+        lines.push(`  ${fieldName}?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}_NOT?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}Connection?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}Connection_NOT?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}_ALL?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}_NONE?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}_SINGLE?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}_SOME?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}Connection_ALL?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}Connection_NONE?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}Connection_SINGLE?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}Connection_SOME?: InputMaybe<${connectionWhereName}>;`);
+    }
+    else {
+        // Singular relationship: limited operators
+        lines.push(`  ${fieldName}?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}_NOT?: InputMaybe<${target}Where>;`);
+        lines.push(`  ${fieldName}Connection?: InputMaybe<${connectionWhereName}>;`);
+        lines.push(`  ${fieldName}Connection_NOT?: InputMaybe<${connectionWhereName}>;`);
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Union Where types (per-member keyed)
+// ---------------------------------------------------------------------------
+function emitUnionWhereType(name, members) {
+    const sorted = [...members].sort();
+    const lines = sorted.map((m) => `  ${m}?: InputMaybe<${m}Where>;`);
+    return `export type ${name}Where = {\n${lines.join('\n')}\n};`;
+}
+//# sourceMappingURL=where-emitter.js.map