@nicia-ai/typegraph 0.1.0

package/dist/chunk-VXRVGFCI.js

@@ -0,0 +1,1128 @@
+import { getDialect, EDGE_META_KEYS, NODE_META_KEYS } from './chunk-IIAT36MI.js';
+import { createSchemaIntrospector, jsonPointer, normalizeJsonPointer, parseJsonPointer, resolveFieldTypeInfoAtJsonPointer } from './chunk-K7SQ3SWP.js';
+import { sql } from 'drizzle-orm';
+import { CasingCache } from 'drizzle-orm/casing';
+import { uniqueIndex, index } from 'drizzle-orm/pg-core';
+import { uniqueIndex as uniqueIndex$1, index as index$1 } from 'drizzle-orm/sqlite-core';
+
+function compileNodeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  for (const column of getNodeScopeColumns(index.scope)) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  for (const column of getEdgeScopeColumns(index.scope, index.direction)) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileIndexKeyValue(dialect, propsColumn, pointer, valueType) {
+  switch (valueType) {
+    case "number": {
+      return dialect.jsonExtractNumber(propsColumn, pointer);
+    }
+    case "boolean": {
+      return dialect.jsonExtractBoolean(propsColumn, pointer);
+    }
+    case "date": {
+      return dialect.jsonExtractDate(propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return dialect.jsonExtractText(propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return dialect.jsonExtract(propsColumn, pointer);
+    }
+  }
+}
+function getNodeScopeColumns(scope) {
+  switch (scope) {
+    case "graphAndKind": {
+      return ["graph_id", "kind"];
+    }
+    case "graph": {
+      return ["graph_id"];
+    }
+    case "none": {
+      return [];
+    }
+  }
+}
+function getEdgeScopeColumns(scope, direction) {
+  const base = scope === "graphAndKind" ? ["graph_id", "kind"] : scope === "graph" ? ["graph_id"] : [];
+  if (direction === "out") {
+    return [...base, "from_id"];
+  }
+  if (direction === "in") {
+    return [...base, "to_id"];
+  }
+  return [...base];
+}
+function isIndexWhereLiteralList(value) {
+  return Array.isArray(value);
+}
+function compileIndexWhere(ctx, expression) {
+  switch (expression.__type) {
+    case "index_where_and": {
+      return sql`(${sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        sql` AND `
+      )})`;
+    }
+    case "index_where_or": {
+      return sql`(${sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        sql` OR `
+      )})`;
+    }
+    case "index_where_not": {
+      return sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;
+    }
+    case "index_where_null_check": {
+      const operand = compileIndexWhereOperand(ctx, expression.operand);
+      return expression.op === "isNull" ? sql`${operand} IS NULL` : sql`${operand} IS NOT NULL`;
+    }
+    case "index_where_comparison": {
+      const left = compileIndexWhereOperand(ctx, expression.left);
+      const right = expression.right;
+      if (isIndexWhereLiteralList(right)) {
+        if (expression.op !== "in" && expression.op !== "notIn") {
+          throw new Error(
+            `Operator "${expression.op}" does not support list comparison in index WHERE clause`
+          );
+        }
+        const values = right.map(
+          (literal) => compileIndexWhereLiteral(ctx.dialect, literal)
+        );
+        const operator = expression.op === "in" ? sql`IN` : sql`NOT IN`;
+        return sql`${left} ${operator} (${sql.join(values, sql`, `)})`;
+      }
+      if (expression.op === "in" || expression.op === "notIn") {
+        throw new Error(
+          `Operator "${expression.op}" requires a list of values in index WHERE clause`
+        );
+      }
+      const rightLiteral = compileIndexWhereLiteral(ctx.dialect, right);
+      const opSql = compileComparisonOperator(expression.op);
+      return sql`${left} ${opSql} ${rightLiteral}`;
+    }
+  }
+}
+function compileIndexWhereOperand(ctx, operand) {
+  if (operand.__type === "index_operand_system") {
+    return ctx.systemColumn(operand.column);
+  }
+  const adapter = getDialect(ctx.dialect);
+  const pointer = jsonPointer([operand.field]);
+  switch (operand.valueType) {
+    case "number": {
+      return adapter.jsonExtractNumber(ctx.propsColumn, pointer);
+    }
+    case "boolean": {
+      return adapter.jsonExtractBoolean(ctx.propsColumn, pointer);
+    }
+    case "date": {
+      return adapter.jsonExtractDate(ctx.propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return adapter.jsonExtract(ctx.propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return adapter.jsonExtractText(ctx.propsColumn, pointer);
+    }
+  }
+}
+function compileIndexWhereLiteral(dialect, literal) {
+  switch (literal.valueType) {
+    case "string":
+    case "date": {
+      return sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+    case "number": {
+      return sql.raw(literal.value.toString());
+    }
+    case "boolean": {
+      return getDialect(dialect).booleanLiteral(literal.value);
+    }
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown": {
+      return sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+  }
+}
+function compileComparisonOperator(op) {
+  switch (op) {
+    case "eq": {
+      return sql`=`;
+    }
+    case "neq": {
+      return sql`<>`;
+    }
+    case "gt": {
+      return sql`>`;
+    }
+    case "gte": {
+      return sql`>=`;
+    }
+    case "lt": {
+      return sql`<`;
+    }
+    case "lte": {
+      return sql`<=`;
+    }
+  }
+}
+function escapeStringLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+
+// src/indexes/ddl.ts
+function generateIndexDDL(index, dialect, options = {}) {
+  if (index.__type === "typegraph_node_index") {
+    return generateNodeIndexDDL(index, dialect, options);
+  }
+  return generateEdgeIndexDDL(index, dialect, options);
+}
+function generateNodeIndexDDL(index, dialect, options = {}) {
+  const tableName = options.nodesTableName ?? "typegraph_nodes";
+  return generateTableIndexDDL(index, dialect, tableName, options);
+}
+function generateEdgeIndexDDL(index, dialect, options = {}) {
+  const tableName = options.edgesTableName ?? "typegraph_edges";
+  return generateTableIndexDDL(index, dialect, tableName, options);
+}
+function generateTableIndexDDL(index, dialect, tableName, options) {
+  const ifNotExists = options.ifNotExists ?? true;
+  const propsColumn = sql.raw('"props"');
+  const systemColumn = (column) => sql.raw(quoteIdentifier(column));
+  const keys = index.__type === "typegraph_node_index" ? compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;
+  const whereSql = index.where ? sqlToInlineString(
+    compileIndexWhere(
+      {
+        dialect,
+        propsColumn,
+        systemColumn
+      },
+      index.where
+    ),
+    dialect
+  ) : void 0;
+  const keySql = keys.map((k) => sqlToInlineString(k, dialect)).join(", ");
+  const unique = index.unique ? "UNIQUE " : "";
+  const ifNotExistsSql = ifNotExists ? "IF NOT EXISTS " : "";
+  const whereClause = whereSql ? ` WHERE ${whereSql}` : "";
+  return `CREATE ${unique}INDEX ${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${keySql})${whereClause};`;
+}
+function quoteIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function sqlToInlineString(object, dialect) {
+  const query = object.toQuery({
+    casing: new CasingCache(),
+    escapeName: (name) => name,
+    escapeParam: (_number, value) => inlineParam(value, dialect),
+    escapeString: (value) => escapeStringLiteral2(value),
+    inlineParams: true,
+    invokeSource: "indexes"
+  });
+  if (query.params.length > 0) {
+    throw new Error(
+      "Index DDL generation produced parameters; expected fully inlined SQL"
+    );
+  }
+  return query.sql;
+}
+function inlineParam(value, dialect) {
+  if (value === null || value === void 0) {
+    return "NULL";
+  }
+  if (value instanceof Date) {
+    return escapeStringLiteral2(value.toISOString());
+  }
+  if (typeof value === "string") {
+    return escapeStringLiteral2(value);
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return getDialect(dialect).booleanLiteralString(value);
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  throw new TypeError(
+    "Index DDL generation received an unsupported SQL parameter value"
+  );
+}
+function escapeStringLiteral2(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+
+// src/indexes/define-index.ts
+function defineNodeIndex(node, config) {
+  const scope = config.scope ?? "graphAndKind";
+  const unique = config.unique ?? false;
+  const schemaIntrospector = createSchemaIntrospector(
+    /* @__PURE__ */ new Map([[node.name, { schema: node.schema }]])
+  );
+  const { pointers: fields, valueTypes: fieldValueTypes } = normalizeNodeIndexFieldsOrThrow(
+    node,
+    config.fields,
+    schemaIntrospector,
+    "fields",
+    { allowEmpty: false }
+  );
+  const { pointers: coveringFields, valueTypes: coveringFieldValueTypes } = normalizeNodeIndexFieldsOrThrow(
+    node,
+    config.coveringFields ?? [],
+    schemaIntrospector,
+    "coveringFields",
+    { allowEmpty: true }
+  );
+  assertNoOverlap(fields, coveringFields, "fields", "coveringFields");
+  const where = normalizeWhereInput(
+    config.where,
+    () => createNodeWhereBuilder(node, schemaIntrospector)
+  );
+  const name = config.name ?? generateDefaultIndexName({
+    kind: "node",
+    kindName: node.name,
+    unique,
+    scope,
+    direction: "none",
+    fields,
+    coveringFields
+  });
+  return {
+    __type: "typegraph_node_index",
+    node,
+    nodeKind: node.name,
+    fields,
+    fieldValueTypes,
+    coveringFields,
+    coveringFieldValueTypes,
+    unique,
+    scope,
+    where,
+    name
+  };
+}
+function defineEdgeIndex(edge, config) {
+  const scope = config.scope ?? "graphAndKind";
+  const unique = config.unique ?? false;
+  const direction = config.direction ?? "none";
+  const schemaIntrospector = createSchemaIntrospector(
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map([[edge.name, { schema: edge.schema }]])
+  );
+  const { pointers: fields, valueTypes: fieldValueTypes } = normalizeEdgeIndexFieldsOrThrow(
+    edge,
+    config.fields,
+    schemaIntrospector,
+    "fields",
+    { allowEmpty: false }
+  );
+  const { pointers: coveringFields, valueTypes: coveringFieldValueTypes } = normalizeEdgeIndexFieldsOrThrow(
+    edge,
+    config.coveringFields ?? [],
+    schemaIntrospector,
+    "coveringFields",
+    { allowEmpty: true }
+  );
+  assertNoOverlap(fields, coveringFields, "fields", "coveringFields");
+  const where = normalizeWhereInput(
+    config.where,
+    () => createEdgeWhereBuilder(edge, schemaIntrospector)
+  );
+  const name = config.name ?? generateDefaultIndexName({
+    kind: "edge",
+    kindName: edge.name,
+    unique,
+    scope,
+    direction,
+    fields,
+    coveringFields
+  });
+  return {
+    __type: "typegraph_edge_index",
+    edge,
+    edgeKind: edge.name,
+    fields,
+    fieldValueTypes,
+    coveringFields,
+    coveringFieldValueTypes,
+    unique,
+    scope,
+    direction,
+    where,
+    name
+  };
+}
+function normalizeWhereInput(input, createBuilder) {
+  if (input === void 0) {
+    return void 0;
+  }
+  if (typeof input === "function") {
+    return input(createBuilder());
+  }
+  return input;
+}
+function createNodeWhereBuilder(node, schemaIntrospector) {
+  const shape = getSchemaShape(node.schema);
+  const system = createSystemColumnMapForNode();
+  function getOperand(key) {
+    const systemColumn = system.get(key);
+    if (systemColumn) {
+      return {
+        __type: "index_operand_system",
+        column: systemColumn.column,
+        valueType: systemColumn.valueType
+      };
+    }
+    if (!(key in shape)) {
+      throw new Error(
+        `Unknown field "${key}" in node index WHERE clause for "${node.name}"`
+      );
+    }
+    const info = schemaIntrospector.getFieldTypeInfo(node.name, key);
+    const valueType = info?.valueType;
+    return {
+      __type: "index_operand_prop",
+      field: key,
+      valueType
+    };
+  }
+  return createWhereProxy((key) => getOperand(key));
+}
+function createEdgeWhereBuilder(edge, schemaIntrospector) {
+  const shape = getSchemaShape(edge.schema);
+  const system = createSystemColumnMapForEdge();
+  function getOperand(key) {
+    const systemColumn = system.get(key);
+    if (systemColumn) {
+      return {
+        __type: "index_operand_system",
+        column: systemColumn.column,
+        valueType: systemColumn.valueType
+      };
+    }
+    if (!(key in shape)) {
+      throw new Error(
+        `Unknown field "${key}" in edge index WHERE clause for "${edge.name}"`
+      );
+    }
+    const info = schemaIntrospector.getEdgeFieldTypeInfo(edge.name, key);
+    const valueType = info?.valueType;
+    return {
+      __type: "index_operand_prop",
+      field: key,
+      valueType
+    };
+  }
+  return createWhereProxy((key) => getOperand(key));
+}
+function createWhereProxy(getOperand) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get: (_target, property) => {
+      if (typeof property !== "string") return;
+      if (property === "then") return;
+      if (property === "toJSON") return;
+      const operand = getOperand(property);
+      return createIndexWhereFieldBuilder(operand);
+    }
+  });
+}
+function createIndexWhereFieldBuilder(operand) {
+  function isNull() {
+    return { __type: "index_where_null_check", operand, op: "isNull" };
+  }
+  function isNotNull() {
+    return { __type: "index_where_null_check", operand, op: "isNotNull" };
+  }
+  function comparison(op, value) {
+    return {
+      __type: "index_where_comparison",
+      left: operand,
+      op,
+      right: toLiteralOrThrow(value, operand.valueType)
+    };
+  }
+  function listComparison(op, values) {
+    const literals = values.map(
+      (value) => toLiteralOrThrow(value, operand.valueType)
+    );
+    return {
+      __type: "index_where_comparison",
+      left: operand,
+      op,
+      right: literals
+    };
+  }
+  return {
+    eq: (value) => comparison("eq", value),
+    neq: (value) => comparison("neq", value),
+    gt: (value) => comparison("gt", value),
+    gte: (value) => comparison("gte", value),
+    lt: (value) => comparison("lt", value),
+    lte: (value) => comparison("lte", value),
+    in: (values) => listComparison("in", values),
+    notIn: (values) => listComparison("notIn", values),
+    isNull,
+    isNotNull
+  };
+}
+function toLiteralOrThrow(value, preferredType) {
+  if (value instanceof Date) {
+    return {
+      __type: "index_where_literal",
+      value: value.toISOString(),
+      valueType: "date"
+    };
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    const valueType = inferValueType(value, preferredType);
+    return { __type: "index_where_literal", value, valueType };
+  }
+  throw new Error(
+    `Unsupported literal value type in index WHERE clause: ${String(value)}`
+  );
+}
+function inferValueType(value, preferredType) {
+  if (preferredType === "date" && typeof value === "string") {
+    return "date";
+  }
+  if (preferredType === "number" && typeof value === "string") {
+    return "number";
+  }
+  if (preferredType === "boolean" && typeof value === "string") {
+    return "boolean";
+  }
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "boolean";
+}
+function toSystemColumnName(metaKey) {
+  const snake = metaKey.replaceAll(/([A-Z])/g, "_$1").toLowerCase();
+  switch (snake) {
+    case "deleted_at":
+    case "valid_from":
+    case "valid_to":
+    case "created_at":
+    case "updated_at": {
+      return snake;
+    }
+    default: {
+      throw new Error(`Unsupported system meta key: ${metaKey}`);
+    }
+  }
+}
+function createSystemColumnMapForNode() {
+  const entries = [
+    ["graphId", { column: "graph_id", valueType: "string" }],
+    ["kind", { column: "kind", valueType: "string" }],
+    ["id", { column: "id", valueType: "string" }]
+  ];
+  for (const key of NODE_META_KEYS) {
+    if (key === "version") {
+      entries.push([key, { column: "version", valueType: "number" }]);
+      continue;
+    }
+    entries.push([key, { column: toSystemColumnName(key), valueType: "date" }]);
+  }
+  return new Map(entries);
+}
+function createSystemColumnMapForEdge() {
+  const entries = [
+    ["graphId", { column: "graph_id", valueType: "string" }],
+    ["kind", { column: "kind", valueType: "string" }],
+    ["id", { column: "id", valueType: "string" }],
+    ["fromKind", { column: "from_kind", valueType: "string" }],
+    ["fromId", { column: "from_id", valueType: "string" }],
+    ["toKind", { column: "to_kind", valueType: "string" }],
+    ["toId", { column: "to_id", valueType: "string" }]
+  ];
+  for (const key of EDGE_META_KEYS) {
+    entries.push([key, { column: toSystemColumnName(key), valueType: "date" }]);
+  }
+  return new Map(entries);
+}
+function getSchemaShape(schema) {
+  if (schema.type !== "object") {
+    throw new Error("Index definitions require an object schema");
+  }
+  const def = schema.def;
+  const shape = def.shape;
+  if (!shape) {
+    throw new Error("Index definitions require a resolvable object shape");
+  }
+  return shape;
+}
+function assertNonEmpty(values, label) {
+  if (values.length === 0) {
+    throw new Error(`Index ${label} must not be empty`);
+  }
+}
+function assertUnique(values, label) {
+  const set = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (set.has(value)) {
+      throw new Error(`Index ${label} contains duplicate value: ${value}`);
+    }
+    set.add(value);
+  }
+}
+function assertNoOverlap(a, b, aLabel, bLabel) {
+  const set = new Set(a);
+  for (const value of b) {
+    if (set.has(value)) {
+      throw new Error(`Index ${bLabel} must not overlap ${aLabel}: ${value}`);
+    }
+  }
+}
+function assertIndexableValueType(valueType, context) {
+  if (valueType === "embedding") {
+    throw new Error(
+      `Cannot create props index for embedding field (${context}); use vector indexes on the embeddings table instead`
+    );
+  }
+  if (valueType === "array" || valueType === "object") {
+    throw new Error(
+      `Cannot create btree props index for ${valueType} field (${context}); use a GIN/JSON index strategy instead`
+    );
+  }
+}
+function normalizeNodeIndexFieldsOrThrow(node, inputs, schemaIntrospector, label, options) {
+  if (inputs.length === 0 && options.allowEmpty) {
+    return { pointers: [], valueTypes: [] };
+  }
+  assertNonEmpty(inputs, label);
+  const pointers = [];
+  const valueTypes = [];
+  for (const input of inputs) {
+    const pointer = normalizeIndexFieldPointer(input);
+    const info = resolveNodeFieldTypeInfoOrThrow(
+      node.name,
+      pointer,
+      schemaIntrospector
+    );
+    assertIndexableValueType(info.valueType, `node "${node.name}" ${pointer}`);
+    pointers.push(pointer);
+    valueTypes.push(info.valueType);
+  }
+  assertUnique(pointers, label);
+  return { pointers, valueTypes };
+}
+function normalizeEdgeIndexFieldsOrThrow(edge, inputs, schemaIntrospector, label, options) {
+  if (inputs.length === 0 && options.allowEmpty) {
+    return { pointers: [], valueTypes: [] };
+  }
+  assertNonEmpty(inputs, label);
+  const pointers = [];
+  const valueTypes = [];
+  for (const input of inputs) {
+    const pointer = normalizeIndexFieldPointer(input);
+    const info = resolveEdgeFieldTypeInfoOrThrow(
+      edge.name,
+      pointer,
+      schemaIntrospector
+    );
+    assertIndexableValueType(info.valueType, `edge "${edge.name}" ${pointer}`);
+    pointers.push(pointer);
+    valueTypes.push(info.valueType);
+  }
+  assertUnique(pointers, label);
+  return { pointers, valueTypes };
+}
+function normalizeIndexFieldPointer(input) {
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      throw new Error("Index field JSON pointer must not be empty");
+    }
+    return jsonPointer(input);
+  }
+  if (typeof input === "string") {
+    if (input.startsWith("/")) {
+      const pointer = normalizeJsonPointer(
+        input
+      );
+      if (pointer === "") {
+        throw new Error("Index field JSON pointer must not be empty");
+      }
+      return pointer;
+    }
+    return jsonPointer([input]);
+  }
+  throw new Error(`Unsupported index field input: ${String(input)}`);
+}
+function resolveNodeFieldTypeInfoOrThrow(nodeKind, pointer, schemaIntrospector) {
+  const segments = parseJsonPointer(pointer);
+  const [first, ...rest] = segments;
+  if (!first) {
+    throw new Error("Index field JSON pointer must not be empty");
+  }
+  const rootInfo = schemaIntrospector.getFieldTypeInfo(nodeKind, first);
+  if (!rootInfo) {
+    throw new Error(
+      `Unknown field "${first}" for node "${nodeKind}" in index definition`
+    );
+  }
+  if (rest.length === 0) {
+    return rootInfo;
+  }
+  const resolved = resolveFieldTypeInfoAtJsonPointer(
+    rootInfo,
+    jsonPointer(rest)
+  );
+  if (!resolved) {
+    throw new Error(
+      `Unknown JSON pointer "${pointer}" for node "${nodeKind}" in index definition`
+    );
+  }
+  return resolved;
+}
+function resolveEdgeFieldTypeInfoOrThrow(edgeKind, pointer, schemaIntrospector) {
+  const segments = parseJsonPointer(pointer);
+  const [first, ...rest] = segments;
+  if (!first) {
+    throw new Error("Index field JSON pointer must not be empty");
+  }
+  const rootInfo = schemaIntrospector.getEdgeFieldTypeInfo(edgeKind, first);
+  if (!rootInfo) {
+    throw new Error(
+      `Unknown field "${first}" for edge "${edgeKind}" in index definition`
+    );
+  }
+  if (rest.length === 0) {
+    return rootInfo;
+  }
+  const resolved = resolveFieldTypeInfoAtJsonPointer(
+    rootInfo,
+    jsonPointer(rest)
+  );
+  if (!resolved) {
+    throw new Error(
+      `Unknown JSON pointer "${pointer}" for edge "${edgeKind}" in index definition`
+    );
+  }
+  return resolved;
+}
+function generateDefaultIndexName(parts) {
+  const hash = fnv1aBase36Hash(
+    JSON.stringify({
+      kind: parts.kind,
+      kindName: parts.kindName,
+      unique: parts.unique,
+      scope: parts.scope,
+      direction: parts.direction,
+      fields: parts.fields,
+      covering: parts.coveringFields
+    })
+  );
+  const nameParts = [
+    "idx",
+    "tg",
+    parts.kind,
+    sanitizeIdentifierComponent(parts.kindName),
+    sanitizeIdentifierComponent(parts.fields.join("_")),
+    parts.coveringFields.length > 0 ? `cov_${sanitizeIdentifierComponent(parts.coveringFields.join("_"))}` : void 0,
+    parts.direction === "none" ? void 0 : parts.direction,
+    parts.unique ? "uniq" : void 0,
+    parts.scope === "graphAndKind" ? void 0 : sanitizeIdentifierComponent(parts.scope),
+    hash
+  ].filter((part) => part !== void 0);
+  const joined = nameParts.join("_");
+  return joined.length <= 63 ? joined : `${joined.slice(0, 54)}_${hash}`;
+}
+function sanitizeIdentifierComponent(value) {
+  return value.toLowerCase().replaceAll(/[^a-z0-9_]+/g, "_").replaceAll(/^_+|_+$/g, "").slice(0, 20);
+}
+function fnv1aBase36Hash(input) {
+  let hash = 2166136261;
+  for (const character of input) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === void 0) {
+      continue;
+    }
+    hash ^= codePoint;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function buildPostgresNodeIndexBuilders(table, indexes) {
+  const nodeIndexes = indexes.filter(
+    (index) => index.__type === "typegraph_node_index"
+  );
+  return nodeIndexes.map((index$1) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getPostgresNodeSystemColumn(table, column)}`;
+    const { keys } = compileNodeIndexKeys(
+      index$1,
+      "postgres",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty2(keys, `node index "${index$1.name}"`);
+    const base = index$1.unique ? uniqueIndex(index$1.name) : index(index$1.name);
+    const builder = base.on(...keys);
+    if (index$1.where) {
+      const ctx = {
+        dialect: "postgres",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index$1.where));
+    }
+    return builder;
+  });
+}
+function buildPostgresEdgeIndexBuilders(table, indexes) {
+  const edgeIndexes = indexes.filter(
+    (index) => index.__type === "typegraph_edge_index"
+  );
+  return edgeIndexes.map((index$1) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getPostgresEdgeSystemColumn(table, column)}`;
+    const { keys } = compileEdgeIndexKeys(
+      index$1,
+      "postgres",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty2(keys, `edge index "${index$1.name}"`);
+    const base = index$1.unique ? uniqueIndex(index$1.name) : index(index$1.name);
+    const builder = base.on(...keys);
+    if (index$1.where) {
+      const ctx = {
+        dialect: "postgres",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index$1.where));
+    }
+    return builder;
+  });
+}
+function getPostgresNodeSystemColumn(table, column) {
+  switch (column) {
+    case "graph_id": {
+      return table.graphId;
+    }
+    case "kind": {
+      return table.kind;
+    }
+    case "id": {
+      return table.id;
+    }
+    case "from_kind":
+    case "from_id":
+    case "to_kind":
+    case "to_id": {
+      throw new Error(`Unsupported node system column for indexes: ${column}`);
+    }
+    case "deleted_at": {
+      return table.deletedAt;
+    }
+    case "valid_from": {
+      return table.validFrom;
+    }
+    case "valid_to": {
+      return table.validTo;
+    }
+    case "created_at": {
+      return table.createdAt;
+    }
+    case "updated_at": {
+      return table.updatedAt;
+    }
+    case "version": {
+      return table.version;
+    }
+  }
+}
+function getPostgresEdgeSystemColumn(table, column) {
+  switch (column) {
+    case "graph_id": {
+      return table.graphId;
+    }
+    case "kind": {
+      return table.kind;
+    }
+    case "id": {
+      return table.id;
+    }
+    case "from_kind": {
+      return table.fromKind;
+    }
+    case "from_id": {
+      return table.fromId;
+    }
+    case "to_kind": {
+      return table.toKind;
+    }
+    case "to_id": {
+      return table.toId;
+    }
+    case "deleted_at": {
+      return table.deletedAt;
+    }
+    case "valid_from": {
+      return table.validFrom;
+    }
+    case "valid_to": {
+      return table.validTo;
+    }
+    case "created_at": {
+      return table.createdAt;
+    }
+    case "updated_at": {
+      return table.updatedAt;
+    }
+    case "version": {
+      throw new Error(`Unsupported edge system column for indexes: ${column}`);
+    }
+  }
+}
+function buildSqliteNodeIndexBuilders(table, indexes) {
+  const nodeIndexes = indexes.filter(
+    (index) => index.__type === "typegraph_node_index"
+  );
+  return nodeIndexes.map((index) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getSqliteNodeSystemColumn(table, column)}`;
+    const { keys } = compileNodeIndexKeys(
+      index,
+      "sqlite",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty2(keys, `node index "${index.name}"`);
+    const base = index.unique ? uniqueIndex$1(index.name) : index$1(index.name);
+    const builder = base.on(...keys);
+    if (index.where) {
+      const ctx = {
+        dialect: "sqlite",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index.where));
+    }
+    return builder;
+  });
+}
+function buildSqliteEdgeIndexBuilders(table, indexes) {
+  const edgeIndexes = indexes.filter(
+    (index) => index.__type === "typegraph_edge_index"
+  );
+  return edgeIndexes.map((index) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getSqliteEdgeSystemColumn(table, column)}`;
+    const { keys } = compileEdgeIndexKeys(
+      index,
+      "sqlite",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty2(keys, `edge index "${index.name}"`);
+    const base = index.unique ? uniqueIndex$1(index.name) : index$1(index.name);
+    const builder = base.on(...keys);
+    if (index.where) {
+      const ctx = {
+        dialect: "sqlite",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index.where));
+    }
+    return builder;
+  });
+}
+function getSqliteNodeSystemColumn(table, column) {
+  switch (column) {
+    case "graph_id": {
+      return table.graphId;
+    }
+    case "kind": {
+      return table.kind;
+    }
+    case "id": {
+      return table.id;
+    }
+    case "from_kind":
+    case "from_id":
+    case "to_kind":
+    case "to_id": {
+      throw new Error(`Unsupported node system column for indexes: ${column}`);
+    }
+    case "deleted_at": {
+      return table.deletedAt;
+    }
+    case "valid_from": {
+      return table.validFrom;
+    }
+    case "valid_to": {
+      return table.validTo;
+    }
+    case "created_at": {
+      return table.createdAt;
+    }
+    case "updated_at": {
+      return table.updatedAt;
+    }
+    case "version": {
+      return table.version;
+    }
+  }
+}
+function getSqliteEdgeSystemColumn(table, column) {
+  switch (column) {
+    case "graph_id": {
+      return table.graphId;
+    }
+    case "kind": {
+      return table.kind;
+    }
+    case "id": {
+      return table.id;
+    }
+    case "from_kind": {
+      return table.fromKind;
+    }
+    case "from_id": {
+      return table.fromId;
+    }
+    case "to_kind": {
+      return table.toKind;
+    }
+    case "to_id": {
+      return table.toId;
+    }
+    case "deleted_at": {
+      return table.deletedAt;
+    }
+    case "valid_from": {
+      return table.validFrom;
+    }
+    case "valid_to": {
+      return table.validTo;
+    }
+    case "created_at": {
+      return table.createdAt;
+    }
+    case "updated_at": {
+      return table.updatedAt;
+    }
+    case "version": {
+      throw new Error(`Unsupported edge system column for indexes: ${column}`);
+    }
+  }
+}
+function assertNonEmpty2(values, label) {
+  if (values.length === 0) {
+    throw new Error(`Index must have at least one key (${label})`);
+  }
+}
+
+// src/indexes/profiler.ts
+function toDeclaredIndex(index) {
+  if (index.__type === "typegraph_node_index") {
+    return toDeclaredNodeIndex(index);
+  }
+  return toDeclaredEdgeIndex(index);
+}
+function toDeclaredIndexes(indexes) {
+  return indexes.map((index) => toDeclaredIndex(index));
+}
+function toDeclaredNodeIndex(index) {
+  return {
+    entityType: "node",
+    kind: index.nodeKind,
+    fields: [...index.fields],
+    unique: index.unique,
+    name: index.name
+  };
+}
+function toDeclaredEdgeIndex(index) {
+  return {
+    entityType: "edge",
+    kind: index.edgeKind,
+    fields: [...index.fields],
+    unique: index.unique,
+    name: index.name
+  };
+}
+
+// src/indexes/where.ts
+function andWhere(...predicates) {
+  if (predicates.length === 1) {
+    return predicates[0];
+  }
+  return {
+    __type: "index_where_and",
+    predicates
+  };
+}
+function orWhere(...predicates) {
+  if (predicates.length === 1) {
+    return predicates[0];
+  }
+  return {
+    __type: "index_where_or",
+    predicates
+  };
+}
+function notWhere(predicate) {
+  return {
+    __type: "index_where_not",
+    predicate
+  };
+}
+
+export { andWhere, buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders, defineEdgeIndex, defineNodeIndex, generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL, notWhere, orWhere, toDeclaredIndex, toDeclaredIndexes };
+//# sourceMappingURL=chunk-VXRVGFCI.js.map
+//# sourceMappingURL=chunk-VXRVGFCI.js.map