@nicia-ai/typegraph 0.28.1 → 0.30.0

package/dist/chunk-IE6GN7L3.cjs

@@ -0,0 +1,319 @@
+'use strict';
+
+var chunkUESTHN47_cjs = require('./chunk-UESTHN47.cjs');
+var drizzleOrm = require('drizzle-orm');
+var pgCore = require('drizzle-orm/pg-core');
+
+pgCore.customType({
+  dataType(config) {
+    return config?.dimensions ? `vector(${config.dimensions})` : "vector";
+  },
+  toDriver(value) {
+    return `[${value.join(",")}]`;
+  },
+  fromDriver(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    const content = value.slice(1, -1);
+    if (content === "") {
+      return [];
+    }
+    return content.split(",").map((s) => Number.parseFloat(s.trim()));
+  }
+});
+function formatVector(embedding) {
+  return `[${embedding.join(",")}]`;
+}
+
+// src/query/dialect/vector/pgvector-strategy.ts
+var TABLE_PREFIX = "tg_vec";
+var INDEX_PREFIX = "tg_vecidx";
+var MAX_HNSW_EF_SEARCH = 1e3;
+function assertPgvectorEfSearch(efSearch) {
+  if (efSearch === void 0) return;
+  if (!Number.isInteger(efSearch) || efSearch <= 0) {
+    throw new Error(`efSearch must be a positive integer, got: ${efSearch}`);
+  }
+  if (efSearch > MAX_HNSW_EF_SEARCH) {
+    throw new RangeError(
+      `efSearch must be \u2264 ${MAX_HNSW_EF_SEARCH} (pgvector's hnsw.ef_search valid range is 1..${MAX_HNSW_EF_SEARCH}), got: ${efSearch}`
+    );
+  }
+}
+var PGVECTOR_MAX_DIMENSIONS = 16e3;
+var DEFAULT_HNSW_M = 16;
+var DEFAULT_HNSW_EF_CONSTRUCTION = 64;
+var DEFAULT_IVFFLAT_LISTS = 100;
+var PGVECTOR_CAPABILITIES = {
+  supported: true,
+  metrics: ["cosine", "l2", "inner_product"],
+  indexTypes: ["hnsw", "ivfflat", "none"],
+  maxDimensions: PGVECTOR_MAX_DIMENSIONS
+};
+function usesAnnIndex(slot) {
+  return slot.indexType === "hnsw" || slot.indexType === "ivfflat";
+}
+function operatorClass(metric) {
+  switch (metric) {
+    case "cosine": {
+      return "vector_cosine_ops";
+    }
+    case "l2": {
+      return "vector_l2_ops";
+    }
+    case "inner_product": {
+      return "vector_ip_ops";
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+function vectorLiteral(embedding, name) {
+  chunkUESTHN47_cjs.assertFiniteEmbedding(embedding, name);
+  return drizzleOrm.sql`${formatVector(embedding)}::vector`;
+}
+function distanceExpression(embeddingColumn, queryEmbedding, metric) {
+  const query = vectorLiteral(queryEmbedding, "queryEmbedding");
+  switch (metric) {
+    case "cosine": {
+      return drizzleOrm.sql`(${embeddingColumn} <=> ${query})`;
+    }
+    case "l2": {
+      return drizzleOrm.sql`(${embeddingColumn} <-> ${query})`;
+    }
+    case "inner_product": {
+      return drizzleOrm.sql`(${embeddingColumn} <#> ${query})`;
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+var pgvectorStrategy = {
+  name: "pgvector",
+  capabilities: PGVECTOR_CAPABILITIES,
+  tableName(graphId, nodeKind, fieldPath) {
+    return chunkUESTHN47_cjs.vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);
+  },
+  ownedTables(slot) {
+    const table = this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath);
+    const name = chunkUESTHN47_cjs.quoteIdentifier(table);
+    const createDdl = [
+      `CREATE TABLE IF NOT EXISTS ${name} (
+  "graph_id" TEXT NOT NULL,
+  "node_id" TEXT NOT NULL,
+  "embedding" vector(${slot.dimensions}) NOT NULL,
+  "created_at" TIMESTAMPTZ NOT NULL,
+  "updated_at" TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY ("graph_id", "node_id")
+);`
+    ];
+    return [
+      {
+        logicalName: `${chunkUESTHN47_cjs.VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,
+        owner: "pgvector",
+        tableName: table,
+        createDdl,
+        runtimeEnsure: true
+      }
+    ];
+  },
+  buildUpsert(slot, params, timestamp) {
+    const table = chunkUESTHN47_cjs.quotedTableName(
+      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
+    );
+    const value = vectorLiteral(params.embedding, "embedding");
+    return [
+      drizzleOrm.sql`
+        INSERT INTO ${table} ("graph_id", "node_id", "embedding", "created_at", "updated_at")
+        VALUES (${params.graphId}, ${params.nodeId}, ${value}, ${timestamp}, ${timestamp})
+        ON CONFLICT ("graph_id", "node_id")
+        DO UPDATE SET "embedding" = EXCLUDED."embedding", "updated_at" = EXCLUDED."updated_at"
+      `
+    ];
+  },
+  buildDelete(slot, params) {
+    const table = chunkUESTHN47_cjs.quotedTableName(
+      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
+    );
+    return [
+      drizzleOrm.sql`
+        DELETE FROM ${table}
+        WHERE "graph_id" = ${params.graphId} AND "node_id" = ${params.nodeId}
+      `
+    ];
+  },
+  buildSearch(slot, params) {
+    const table = chunkUESTHN47_cjs.quotedTableName(
+      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
+    );
+    const embeddingColumn = drizzleOrm.sql`${table}."embedding"`;
+    const distance = distanceExpression(
+      embeddingColumn,
+      params.queryEmbedding,
+      params.metric
+    );
+    const score = chunkUESTHN47_cjs.vectorScoreExpression(distance, params.metric);
+    const conditions = [drizzleOrm.sql`${table}."graph_id" = ${params.graphId}`];
+    if (params.minScore !== void 0) {
+      conditions.push(
+        chunkUESTHN47_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
+      );
+    }
+    return drizzleOrm.sql`
+      SELECT ${table}."node_id" AS node_id, ${score} AS score
+      FROM ${table}
+      WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
+      ORDER BY ${distance} ASC
+      LIMIT ${params.limit}
+    `;
+  },
+  distanceExpression(embeddingColumn, queryEmbedding, metric) {
+    return distanceExpression(embeddingColumn, queryEmbedding, metric);
+  },
+  buildCreateIndex(slot, options) {
+    if (!usesAnnIndex(slot)) return void 0;
+    return drizzleOrm.sql.raw(
+      pgvectorIndexDdl(
+        this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),
+        slot,
+        options?.concurrent === true
+      )
+    );
+  },
+  buildDropIndex(slot) {
+    if (!usesAnnIndex(slot)) return void 0;
+    const indexName = pgvectorIndexName(slot);
+    return drizzleOrm.sql.raw(`DROP INDEX IF EXISTS ${chunkUESTHN47_cjs.quoteIdentifier(indexName)}`);
+  },
+  buildDropStorage(slot) {
+    const table = chunkUESTHN47_cjs.quoteIdentifier(
+      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
+    );
+    return [`DROP TABLE IF EXISTS ${table} CASCADE`];
+  }
+};
+function pgvectorIndexName(slot) {
+  return chunkUESTHN47_cjs.vectorPhysicalName(
+    INDEX_PREFIX,
+    slot.graphId,
+    slot.nodeKind,
+    slot.fieldPath
+  );
+}
+function pgvectorIndexDdl(table, slot, concurrent) {
+  const indexName = chunkUESTHN47_cjs.quoteIdentifier(pgvectorIndexName(slot));
+  const quotedTable = chunkUESTHN47_cjs.quoteIdentifier(table);
+  const opClass = operatorClass(slot.metric);
+  const m = slot.indexParams?.m ?? DEFAULT_HNSW_M;
+  const efConstruction = slot.indexParams?.efConstruction ?? DEFAULT_HNSW_EF_CONSTRUCTION;
+  const lists = slot.indexParams?.lists ?? DEFAULT_IVFFLAT_LISTS;
+  const create = `CREATE INDEX${concurrent ? " CONCURRENTLY" : ""} IF NOT EXISTS`;
+  switch (slot.indexType) {
+    case "hnsw": {
+      return `${create} ${indexName} ON ${quotedTable} USING hnsw ("embedding" ${opClass}) WITH (m = ${m}, ef_construction = ${efConstruction});`;
+    }
+    case "ivfflat": {
+      return `${create} ${indexName} ON ${quotedTable} USING ivfflat ("embedding" ${opClass}) WITH (lists = ${lists});`;
+    }
+    case "none": {
+      throw new Error(
+        "pgvectorIndexDdl called for a brute-force-only slot (indexType 'none')."
+      );
+    }
+    default: {
+      const _exhaustive = slot.indexType;
+      throw new Error(`Unsupported vector index type: ${String(_exhaustive)}`);
+    }
+  }
+}
+var NODE_COLUMNS = [
+  "id",
+  "kind",
+  "props",
+  "version",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EDGE_COLUMNS = [
+  "id",
+  "kind",
+  "from_id",
+  "to_id",
+  "props",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
+function quoteIdentifier2(identifier) {
+  return drizzleOrm.sql.raw(`"${identifier.replaceAll('"', '""')}"`);
+}
+function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
+  if (alwaysRequiredColumns?.has(column)) return true;
+  if (requiredColumns === void 0) return true;
+  return requiredColumns.has(column);
+}
+function addRequiredColumn(requiredColumnsByAlias, alias, column) {
+  const existing = requiredColumnsByAlias.get(alias);
+  if (existing) {
+    existing.add(column);
+    return;
+  }
+  requiredColumnsByAlias.set(alias, /* @__PURE__ */ new Set([column]));
+}
+function markFieldRefAsRequired(requiredColumnsByAlias, field) {
+  const column = field.path[0];
+  if (column === void 0) return;
+  addRequiredColumn(requiredColumnsByAlias, field.alias, column);
+}
+function mapSelectiveSystemFieldToColumn(field) {
+  if (field === "fromId") return "from_id";
+  if (field === "toId") return "to_id";
+  if (field.startsWith("meta.")) {
+    return field.slice(5).replaceAll(/([A-Z])/g, "_$1").toLowerCase();
+  }
+  return field;
+}
+function markSelectiveFieldAsRequired(requiredColumnsByAlias, field) {
+  if (field.isSystemField) {
+    addRequiredColumn(
+      requiredColumnsByAlias,
+      field.alias,
+      mapSelectiveSystemFieldToColumn(field.field)
+    );
+    return;
+  }
+  addRequiredColumn(requiredColumnsByAlias, field.alias, "props");
+}
+function isIdFieldRef(field) {
+  return field.path.length === 1 && field.path[0] === "id" && field.jsonPointer === void 0;
+}
+function isAggregateExpr(source) {
+  return "__type" in source && source.__type === "aggregate";
+}
+
+exports.EDGE_COLUMNS = EDGE_COLUMNS;
+exports.EMPTY_REQUIRED_COLUMNS = EMPTY_REQUIRED_COLUMNS;
+exports.NODE_COLUMNS = NODE_COLUMNS;
+exports.addRequiredColumn = addRequiredColumn;
+exports.assertPgvectorEfSearch = assertPgvectorEfSearch;
+exports.isAggregateExpr = isAggregateExpr;
+exports.isIdFieldRef = isIdFieldRef;
+exports.mapSelectiveSystemFieldToColumn = mapSelectiveSystemFieldToColumn;
+exports.markFieldRefAsRequired = markFieldRefAsRequired;
+exports.markSelectiveFieldAsRequired = markSelectiveFieldAsRequired;
+exports.pgvectorStrategy = pgvectorStrategy;
+exports.quoteIdentifier = quoteIdentifier2;
+exports.shouldProjectColumn = shouldProjectColumn;
+//# sourceMappingURL=chunk-IE6GN7L3.cjs.map
+//# sourceMappingURL=chunk-IE6GN7L3.cjs.map

package/dist/chunk-IE6GN7L3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/drizzle/columns/vector.ts","../src/query/dialect/vector/pgvector-strategy.ts","../src/query/compiler/utils.ts"],"names":["customType","assertFiniteEmbedding","sql","vectorPhysicalName","quoteIdentifier","VECTOR_CONTRIBUTION_PREFIX","quotedTableName","vectorScoreExpression","vectorMinScoreCondition"],"mappings":";;;;;;AA0CsBA,iBAAA,CAInB;AAAA,EACD,SAAS,MAAA,EAAQ;AAEf,IAAA,OAAO,MAAA,EAAQ,UAAA,GAAa,CAAA,OAAA,EAAU,MAAA,CAAO,UAAU,CAAA,CAAA,CAAA,GAAM,QAAA;AAAA,EAC/D,CAAA;AAAA,EAEA,SAAS,KAAA,EAAyB;AAEhC,IAAA,OAAO,CAAA,CAAA,EAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,EAC5B,CAAA;AAAA,EAEA,WAAW,KAAA,EAAyB;AAGlC,IAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,MAAA,OAAO,KAAA;AAAA,IACT;AAEA,IAAA,MAAM,OAAA,GAAU,KAAA,CAAM,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA;AACjC,IAAA,IAAI,YAAY,EAAA,EAAI;AAClB,MAAA,OAAO,EAAC;AAAA,IACV;AACA,IAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,CAAI,CAAC,CAAA,KAAM,MAAA,CAAO,UAAA,CAAW,CAAA,CAAE,IAAA,EAAM,CAAC,CAAA;AAAA,EAClE;AACF,CAAC;AAgBM,SAAS,aAAa,SAAA,EAAsC;AACjE,EAAA,OAAO,CAAA,CAAA,EAAI,SAAA,CAAU,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAChC;;;ACzCA,IAAM,YAAA,GAAe,QAAA;AACrB,IAAM,YAAA,GAAe,WAAA;AASd,IAAM,kBAAA,GAAqB,GAAA;AAM3B,SAAS,uBAAuB,QAAA,EAAyB;AAC9D,EAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,EAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,QAAQ,CAAA,IAAK,YAAY,CAAA,EAAG;AAChD,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,0CAAA,EAA6C,QAAQ,CAAA,CAAE,CAAA;AAAA,EACzE;AACA,EAAA,IAAI,WAAW,kBAAA,EAAoB;AACjC,IAAA,MAAM,IAAI,UAAA;AAAA,MACR,CAAA,wBAAA,EAAsB,kBAAkB,CAAA,8CAAA,EACjB,kBAAkB,WAAW,QAAQ,CAAA;AAAA,KAC9D;AAAA,EACF;AACF;AAQA,IAAM,uBAAA,GAA0B,IAAA;AAGhC,IAAM,cAAA,GAAiB,EAAA;AAEvB,IAAM,4BAAA,GAA+B,EAAA;AAErC,IAAM,qBAAA,GAAwB,GAAA;AAE9B,IAAM,qBAAA,GAA4C;AAAA,EAChD,SAAA,EAAW,IAAA;AAAA,EACX,OAAA,EAAS,CAAC,QAAA,EAAU,IAAA,EAAM,eAAe,CAAA;AAAA,EACzC,UAAA,EAAY,CAAC,MAAA,EAAQ,SAAA,EAAW,MAAM,CAAA;AAAA,EACtC,aAAA,EAAe;AACjB,CAAA;AAGA,SAAS,aAAa,IAAA,EAA2B;AAC/C,EAAA,OAAO,IAAA,CAAK,SAAA,KAAc,MAAA,IAAU,IAAA,CAAK,SAAA,KAAc,SAAA;AACzD;AAOA,SAAS,cAAc,MAAA,EAA8B;AACnD,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,QAAA,EAAU;AACb,MAAA,OAAO,mBAAA;AAAA,IACT;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,eAAA;AAAA,IACT;AAAA,IACA,KAAK,eAAA,EAAiB;AACpB,MAAA,OAAO,eAAA;AAAA,IACT;AAAA,IACA,SAAS;AACP,MAAA,MAAM,WAAA,GAAqB,MAAA;AAC3B,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,2BAAA,EAA8B,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACrE;AAAA;AAEJ;AAOA,SAAS,aAAA,CAAc,WAA8B,IAAA,EAAmB;AACtE,EAAAC,uCAAA,CAAsB,WAAW,IAAI,CAAA;AACrC,EAAA,OAAOC,cAAA,CAAA,EAAM,YAAA,CAAa,SAAS,CAAC,CAAA,QAAA,CAAA;AACtC;AAEA,SAAS,kBAAA,CACP,eAAA,EACA,cAAA,EACA,MAAA,EACK;AACL,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,cAAA,EAAgB,gBAAgB,CAAA;AAC5D,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,QAAA,EAAU;AACb,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,KAAK,eAAA,EAAiB;AACpB,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,SAAS;AACP,MAAA,MAAM,WAAA,GAAqB,MAAA;AAC3B,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,2BAAA,EAA8B,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACrE;AAAA;AAEJ;AAEO,IAAM,gBAAA,GAAmC;AAAA,EAC9C,IAAA,EAAM,UAAA;AAAA,EACN,YAAA,EAAc,qBAAA;AAAA,EAEd,SAAA,CAAU,OAAA,EAAS,QAAA,EAAU,SAAA,EAAW;AACtC,IAAA,OAAOC,oCAAA,CAAmB,YAAA,EAAc,OAAA,EAAS,QAAA,EAAU,SAAS,CAAA;AAAA,EACtE,CAAA;AAAA,EAEA,YAAY,IAAA,EAA4C;AACtD,IAAA,MAAM,KAAA,GAAQ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS,CAAA;AACxE,IAAA,MAAM,IAAA,GAAOC,kCAAgB,KAAK,CAAA;AAKlC,IAAA,MAAM,SAAA,GAAY;AAAA,MAChB,8BAA8B,IAAI,CAAA;AAAA;AAAA;AAAA,qBAAA,EAGjB,KAAK,UAAU,CAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAAA,KAKlC;AAWA,IAAA,OAAO;AAAA,MACL;AAAA,QACE,WAAA,EAAa,GAAGC,4CAA0B,CAAA,CAAA,EAAI,KAAK,QAAQ,CAAA,CAAA,EAAI,KAAK,SAAS,CAAA,CAAA;AAAA,QAC7E,KAAA,EAAO,UAAA;AAAA,QACP,SAAA,EAAW,KAAA;AAAA,QACX,SAAA;AAAA,QACA,aAAA,EAAe;AAAA;AACjB,KACF;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,IAAA,EAAM,MAAA,EAA+B,SAAA,EAA2B;AAC1E,IAAA,MAAM,KAAA,GAAQC,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,MAAA,CAAO,SAAA,EAAW,WAAW,CAAA;AACzD,IAAA,OAAO;AAAA,MACLJ,cAAA;AAAA,oBAAA,EACgB,KAAK,CAAA;AAAA,gBAAA,EACT,MAAA,CAAO,OAAO,CAAA,EAAA,EAAK,MAAA,CAAO,MAAM,KAAK,KAAK,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA;AAAA;AAAA;AAAA,MAAA;AAAA,KAIpF;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,MAAM,MAAA,EAA+C;AAC/D,IAAA,MAAM,KAAA,GAAQI,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,OAAO;AAAA,MACLJ,cAAA;AAAA,oBAAA,EACgB,KAAK;AAAA,2BAAA,EACE,MAAA,CAAO,OAAO,CAAA,iBAAA,EAAoB,MAAA,CAAO,MAAM;AAAA,MAAA;AAAA,KAExE;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,MAAM,MAAA,EAAiC;AACjD,IAAA,MAAM,KAAA,GAAQI,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,MAAM,eAAA,GAAkBJ,iBAAM,KAAK,CAAA,YAAA,CAAA;AACnC,IAAA,MAAM,QAAA,GAAW,kBAAA;AAAA,MACf,eAAA;AAAA,MACA,MAAA,CAAO,cAAA;AAAA,MACP,MAAA,CAAO;AAAA,KACT;AACA,IAAA,MAAM,KAAA,GAAQK,uCAAA,CAAsB,QAAA,EAAU,MAAA,CAAO,MAAM,CAAA;AAK3D,IAAA,MAAM,aAAoB,CAACL,cAAA,CAAA,EAAM,KAAK,CAAA,cAAA,EAAiB,MAAA,CAAO,OAAO,CAAA,CAAE,CAAA;AACvE,IAAA,IAAI,MAAA,CAAO,aAAa,MAAA,EAAW;AACjC,MAAA,UAAA,CAAW,IAAA;AAAA,QACTM,yCAAA,CAAwB,QAAA,EAAU,MAAA,CAAO,MAAA,EAAQ,OAAO,QAAQ;AAAA,OAClE;AAAA,IACF;AACA,IAAA,OAAON,cAAA;AAAA,aAAA,EACI,KAAK,0BAA0B,KAAK,CAAA;AAAA,WAAA,EACtC,KAAK;AAAA,YAAA,EACJA,cAAA,CAAI,IAAA,CAAK,UAAA,EAAYA,cAAA,CAAA,KAAA,CAAU,CAAC;AAAA,eAAA,EAC7B,QAAQ,CAAA;AAAA,YAAA,EACX,OAAO,KAAK;AAAA,IAAA,CAAA;AAAA,EAExB,CAAA;AAAA,EAEA,kBAAA,CAAmB,eAAA,EAAiB,cAAA,EAAgB,MAAA,EAAQ;AAC1D,IAAA,OAAO,kBAAA,CAAmB,eAAA,EAAiB,cAAA,EAAgB,MAAM,CAAA;AAAA,EACnE,CAAA;AAAA,EAEA,gBAAA,CAAiB,MAAM,OAAA,EAA0B;AAC/C,IAAA,IAAI,CAAC,YAAA,CAAa,IAAI,CAAA,EAAG,OAAO,MAAA;AAChC,IAAA,OAAOA,cAAA,CAAI,GAAA;AAAA,MACT,gBAAA;AAAA,QACE,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS,CAAA;AAAA,QAC1D,IAAA;AAAA,QACA,SAAS,UAAA,KAAe;AAAA;AAC1B,KACF;AAAA,EACF,CAAA;AAAA,EAEA,eAAe,IAAA,EAAuB;AACpC,IAAA,IAAI,CAAC,YAAA,CAAa,IAAI,CAAA,EAAG,OAAO,MAAA;AAChC,IAAA,MAAM,SAAA,GAAY,kBAAkB,IAAI,CAAA;AACxC,IAAA,OAAOA,eAAI,GAAA,CAAI,CAAA,qBAAA,EAAwBE,iCAAA,CAAgB,SAAS,CAAC,CAAA,CAAE,CAAA;AAAA,EACrE,CAAA;AAAA,EAEA,iBAAiB,IAAA,EAAyB;AACxC,IAAA,MAAM,KAAA,GAAQA,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AAEA,IAAA,OAAO,CAAC,CAAA,qBAAA,EAAwB,KAAK,CAAA,QAAA,CAAU,CAAA;AAAA,EACjD;AACF;AAEA,SAAS,kBAAkB,IAAA,EAA0B;AACnD,EAAA,OAAOD,oCAAA;AAAA,IACL,YAAA;AAAA,IACA,IAAA,CAAK,OAAA;AAAA,IACL,IAAA,CAAK,QAAA;AAAA,IACL,IAAA,CAAK;AAAA,GACP;AACF;AAEA,SAAS,gBAAA,CACP,KAAA,EACA,IAAA,EACA,UAAA,EACQ;AACR,EAAA,MAAM,SAAA,GAAYC,iCAAA,CAAgB,iBAAA,CAAkB,IAAI,CAAC,CAAA;AACzD,EAAA,MAAM,WAAA,GAAcA,kCAAgB,KAAK,CAAA;AACzC,EAAA,MAAM,OAAA,GAAU,aAAA,CAAc,IAAA,CAAK,MAAM,CAAA;AAEzC,EAAA,MAAM,CAAA,GAAI,IAAA,CAAK,WAAA,EAAa,CAAA,IAAK,cAAA;AACjC,EAAA,MAAM,cAAA,GACJ,IAAA,CAAK,WAAA,EAAa,cAAA,IAAkB,4BAAA;AACtC,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,WAAA,EAAa,KAAA,IAAS,qBAAA;AAGzC,EAAA,MAAM,MAAA,GAAS,CAAA,YAAA,EAAe,UAAA,GAAa,eAAA,GAAkB,EAAE,CAAA,cAAA,CAAA;AAE/D,EAAA,QAAQ,KAAK,SAAA;AAAW,IACtB,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,SAAS,CAAA,IAAA,EAAO,WAAW,CAAA,yBAAA,EAA4B,OAAO,CAAA,YAAA,EAAe,CAAC,CAAA,oBAAA,EAAuB,cAAc,CAAA,EAAA,CAAA;AAAA,IACzI;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,SAAS,OAAO,WAAW,CAAA,4BAAA,EAA+B,OAAO,CAAA,gBAAA,EAAmB,KAAK,CAAA,EAAA,CAAA;AAAA,IAC/G;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,IAAI,KAAA;AAAA,QACR;AAAA,OACF;AAAA,IACF;AAAA,IACA,SAAS;AACP,MAAA,MAAM,cAAqB,IAAA,CAAK,SAAA;AAChC,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,+BAAA,EAAkC,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA;AAEJ;AClUO,IAAM,YAAA,GAAe;AAAA,EAC1B,IAAA;AAAA,EACA,MAAA;AAAA,EACA,OAAA;AAAA,EACA,SAAA;AAAA,EACA,YAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,YAAA;AAAA,EACA;AACF;AAEO,IAAM,YAAA,GAAe;AAAA,EAC1B,IAAA;AAAA,EACA,MAAA;AAAA,EACA,SAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA,YAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,YAAA;AAAA,EACA;AACF;AAGO,IAAM,sBAAA,uBAA6B,GAAA;AAMnC,SAASA,iBAAgB,UAAA,EAAyB;AACvD,EAAA,OAAOF,cAAAA,CAAI,IAAI,CAAA,CAAA,EAAI,UAAA,CAAW,WAAW,GAAA,EAAK,IAAI,CAAC,CAAA,CAAA,CAAG,CAAA;AACxD;AAcO,SAAS,mBAAA,CACd,eAAA,EACA,MAAA,EACA,qBAAA,EACS;AACT,EAAA,IAAI,qBAAA,EAAuB,GAAA,CAAI,MAAM,CAAA,EAAG,OAAO,IAAA;AAC/C,EAAA,IAAI,eAAA,KAAoB,QAAW,OAAO,IAAA;AAC1C,EAAA,OAAO,eAAA,CAAgB,IAAI,MAAM,CAAA;AACnC;AAMO,SAAS,iBAAA,CACd,sBAAA,EACA,KAAA,EACA,MAAA,EACM;AACN,EAAA,MAAM,QAAA,GAAW,sBAAA,CAAuB,GAAA,CAAI,KAAK,CAAA;AACjD,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,QAAA,CAAS,IAAI,MAAM,CAAA;AACnB,IAAA;AAAA,EACF;AACA,EAAA,sBAAA,CAAuB,IAAI,KAAA,kBAAO,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;AACrD;AAEO,SAAS,sBAAA,CACd,wBACA,KAAA,EACM;AACN,EAAA,MAAM,MAAA,GAAS,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA;AAC3B,EAAA,IAAI,WAAW,MAAA,EAAW;AAC1B,EAAA,iBAAA,CAAkB,sBAAA,EAAwB,KAAA,CAAM,KAAA,EAAO,MAAM,CAAA;AAC/D;AAEO,SAAS,gCAAgC,KAAA,EAAuB;AACrE,EAAA,IAAI,KAAA,KAAU,UAAU,OAAO,SAAA;AAC/B,EAAA,IAAI,KAAA,KAAU,QAAQ,OAAO,OAAA;AAC7B,EAAA,IAAI,KAAA,CAAM,UAAA,CAAW,OAAO,CAAA,EAAG;AAC7B,IAAA,OAAO,KAAA,CACJ,MAAM,CAAC,CAAA,CACP,WAAW,UAAA,EAAY,KAAK,EAC5B,WAAA,EAAY;AAAA,EACjB;AACA,EAAA,OAAO,KAAA;AACT;AAEO,SAAS,4BAAA,CACd,wBACA,KAAA,EACM;AACN,EAAA,IAAI,MAAM,aAAA,EAAe;AACvB,IAAA,iBAAA;AAAA,MACE,sBAAA;AAAA,MACA,KAAA,CAAM,KAAA;AAAA,MACN,+BAAA,CAAgC,MAAM,KAAK;AAAA,KAC7C;AACA,IAAA;AAAA,EACF;AACA,EAAA,iBAAA,CAAkB,sBAAA,EAAwB,KAAA,CAAM,KAAA,EAAO,OAAO,CAAA;AAChE;AAMO,SAAS,aAAa,KAAA,EAA0B;AACrD,EAAA,OACE,KAAA,CAAM,IAAA,CAAK,MAAA,KAAW,CAAA,IACtB,KAAA,CAAM,KAAK,CAAC,CAAA,KAAM,IAAA,IAClB,KAAA,CAAM,WAAA,KAAgB,MAAA;AAE1B;AAEO,SAAS,gBACd,MAAA,EACyB;AACzB,EAAA,OAAO,QAAA,IAAY,MAAA,IAAU,MAAA,CAAO,MAAA,KAAW,WAAA;AACjD","file":"chunk-IE6GN7L3.cjs","sourcesContent":["/**\n * Custom Drizzle column type for pgvector's VECTOR type.\n *\n * Provides native support for PostgreSQL vector embeddings without\n * requiring runtime casts in queries.\n *\n * @example\n * ```typescript\n * import { pgTable, text, integer } from \"drizzle-orm/pg-core\";\n * import { vector } from \"./columns/vector\";\n *\n * const embeddings = pgTable(\"embeddings\", {\n *   id: text(\"id\").primaryKey(),\n *   embedding: vector(\"embedding\"),\n *   dimensions: integer(\"dimensions\"),\n * });\n * ```\n */\nimport { customType } from \"drizzle-orm/pg-core\";\n\n/**\n * PostgreSQL vector column type for pgvector extension.\n *\n * Stores embeddings as native VECTOR type, enabling efficient\n * similarity search without runtime casts.\n *\n * The column type is unparameterized (`VECTOR` not `VECTOR(N)`)\n * to support multiple embedding dimensions in a single table.\n * Dimension validation is handled at the application level.\n *\n * @example\n * ```typescript\n * // In table definition\n * embedding: vector(\"embedding\").notNull(),\n *\n * // In queries - no cast needed\n * db.execute(sql`\n *   SELECT * FROM embeddings\n *   WHERE embedding <=> ${formatVector([0.1, 0.2, 0.3])} < 0.5\n * `);\n * ```\n */\nexport const vector = customType<{\n  data: number[];\n  driverData: string;\n  config: { dimensions?: number };\n}>({\n  dataType(config) {\n    // Use parameterized type if dimensions specified, otherwise unparameterized\n    return config?.dimensions ? `vector(${config.dimensions})` : \"vector\";\n  },\n\n  toDriver(value: number[]): string {\n    // Format as pgvector literal: [1.0,2.0,3.0]\n    return `[${value.join(\",\")}]`;\n  },\n\n  fromDriver(value: string): number[] {\n    // pgvector returns '[1,2,3]' format\n    // Handle both string and already-parsed array (some drivers differ)\n    if (Array.isArray(value)) {\n      return value as number[];\n    }\n    // Parse the string representation\n    const content = value.slice(1, -1); // Remove [ and ]\n    if (content === \"\") {\n      return [];\n    }\n    return content.split(\",\").map((s) => Number.parseFloat(s.trim()));\n  },\n});\n\n/**\n * Formats a number array as a pgvector literal string.\n *\n * Use this when building raw SQL queries with embeddings.\n *\n * @example\n * ```typescript\n * const embedding = [0.1, 0.2, 0.3];\n * db.execute(sql`\n *   SELECT * FROM embeddings\n *   WHERE embedding <=> ${formatVector(embedding)}::vector < 0.5\n * `);\n * ```\n */\nexport function formatVector(embedding: readonly number[]): string {\n  return `[${embedding.join(\",\")}]`;\n}\n","/**\n * pgvector strategy.\n *\n * Postgres' pgvector extension is the one engine where the *same* SQL serves\n * brute-force and ANN: `ORDER BY embedding <=> q LIMIT k` scans sequentially\n * with no index and is rewritten to an HNSW/IVFFlat scan the moment a matching\n * index exists — the planner picks it up automatically. So `buildSearch` never\n * branches on `slot.indexType`; it emits one relevance scan and lets Postgres\n * decide. (Contrast libSQL/sqlite-vec, whose ANN needs distinct syntax.)\n *\n * Storage is per-`(nodeKind, fieldPath)`: a `vector(N)` column carrying the\n * field's fixed dimension `N`, with the operator-class-typed ANN index folded\n * into the same table contribution so materialization builds table + index\n * together. The typed column means the index does not need the legacy\n * `::vector(N)` cast-in-index escape hatch the old shared table relied on.\n *\n * Metric support is the full pgvector set — `cosine`, `l2`, `inner_product` —\n * advertised as data on `capabilities`, mirroring `vector_cosine_ops` /\n * `vector_l2_ops` / `vector_ip_ops` and the `<=>` / `<->` / `<#>` operators.\n *\n * Mirrors the `libsqlVectorStrategy` / `sqliteVecStrategy` structure while\n * letting Postgres' planner pick the ANN index when one exists.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { formatVector } from \"../../../backend/drizzle/columns/vector\";\nimport { quotedTableName } from \"../../../backend/drizzle/operations/shared\";\nimport { type StrategyTableContribution } from \"../../../backend/table-contribution\";\nimport {\n  type DeleteEmbeddingParams,\n  type UpsertEmbeddingParams,\n  type VectorCapabilities,\n  type VectorMetric,\n  type VectorSearchParams,\n} from \"../../../backend/types\";\nimport {\n  assertFiniteEmbedding,\n  quoteIdentifier,\n  VECTOR_CONTRIBUTION_PREFIX,\n  vectorMinScoreCondition,\n  vectorPhysicalName,\n  vectorScoreExpression,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"../vector-strategy\";\n\n/** Physical-name prefixes for the per-field table and its ANN index. */\nconst TABLE_PREFIX = \"tg_vec\";\nconst INDEX_PREFIX = \"tg_vecidx\";\n\n/**\n * pgvector defines `hnsw.ef_search` as an integer GUC with a valid range\n * of 1..1000; `SET hnsw.ef_search = 1001` errors at the server. The\n * backend validates a per-search `efSearch` against this ceiling before\n * inlining it into `SET LOCAL`, surfacing a clear message instead of a raw\n * pgvector error.\n */\nexport const MAX_HNSW_EF_SEARCH = 1000;\n\n/**\n * Validates a per-search `efSearch` override against pgvector's\n * `hnsw.ef_search` valid range. `undefined` (no override) is accepted.\n */\nexport function assertPgvectorEfSearch(efSearch?: number): void {\n  if (efSearch === undefined) return;\n  if (!Number.isInteger(efSearch) || efSearch <= 0) {\n    throw new Error(`efSearch must be a positive integer, got: ${efSearch}`);\n  }\n  if (efSearch > MAX_HNSW_EF_SEARCH) {\n    throw new RangeError(\n      `efSearch must be ≤ ${MAX_HNSW_EF_SEARCH} (pgvector's hnsw.ef_search ` +\n        `valid range is 1..${MAX_HNSW_EF_SEARCH}), got: ${efSearch}`,\n    );\n  }\n}\n\n/**\n * pgvector's `vector` type caps at 16,000 dimensions for a stored column\n * (2,000 for an indexed column, but the column-type ceiling is what governs\n * storage; recall degradation beyond 2,000 is a tuning concern, not a hard\n * limit advertised here).\n */\nconst PGVECTOR_MAX_DIMENSIONS = 16_000;\n\n/** Default HNSW `m` (max connections per layer) — pgvector's own default. */\nconst DEFAULT_HNSW_M = 16;\n/** Default HNSW `ef_construction` (build candidate list) — pgvector's own default. */\nconst DEFAULT_HNSW_EF_CONSTRUCTION = 64;\n/** Default IVFFlat `lists` (inverted lists) — pgvector's own default. */\nconst DEFAULT_IVFFLAT_LISTS = 100;\n\nconst PGVECTOR_CAPABILITIES: VectorCapabilities = {\n  supported: true,\n  metrics: [\"cosine\", \"l2\", \"inner_product\"],\n  indexTypes: [\"hnsw\", \"ivfflat\", \"none\"],\n  maxDimensions: PGVECTOR_MAX_DIMENSIONS,\n};\n\n/** Whether a slot's declared index type materializes a real pgvector ANN index. */\nfunction usesAnnIndex(slot: VectorSlot): boolean {\n  return slot.indexType === \"hnsw\" || slot.indexType === \"ivfflat\";\n}\n\n/**\n * pgvector operator class for a metric's ANN index — `vector_cosine_ops` /\n * `vector_l2_ops` / `vector_ip_ops`, mirroring the `<=>` / `<->` / `<#>`\n * distance operators this strategy emits.\n */\nfunction operatorClass(metric: VectorMetric): string {\n  switch (metric) {\n    case \"cosine\": {\n      return \"vector_cosine_ops\";\n    }\n    case \"l2\": {\n      return \"vector_l2_ops\";\n    }\n    case \"inner_product\": {\n      return \"vector_ip_ops\";\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\n/**\n * Formats an embedding as a `::vector` literal. The value is bound as a\n * parameter (not interpolated) — Postgres parses the `[a,b,c]` text and the\n * cast types it. Finiteness is validated first so a NaN names its index.\n */\nfunction vectorLiteral(embedding: readonly number[], name: string): SQL {\n  assertFiniteEmbedding(embedding, name);\n  return sql`${formatVector(embedding)}::vector`;\n}\n\nfunction distanceExpression(\n  embeddingColumn: SQL,\n  queryEmbedding: readonly number[],\n  metric: VectorMetric,\n): SQL {\n  const query = vectorLiteral(queryEmbedding, \"queryEmbedding\");\n  switch (metric) {\n    case \"cosine\": {\n      return sql`(${embeddingColumn} <=> ${query})`;\n    }\n    case \"l2\": {\n      return sql`(${embeddingColumn} <-> ${query})`;\n    }\n    case \"inner_product\": {\n      return sql`(${embeddingColumn} <#> ${query})`;\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\nexport const pgvectorStrategy: VectorStrategy = {\n  name: \"pgvector\",\n  capabilities: PGVECTOR_CAPABILITIES,\n\n  tableName(graphId, nodeKind, fieldPath) {\n    return vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);\n  },\n\n  ownedTables(slot): readonly StrategyTableContribution[] {\n    const table = this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath);\n    const name = quoteIdentifier(table);\n\n    // No standalone graph_id index: the PRIMARY KEY (graph_id, node_id) already\n    // covers `WHERE graph_id = ?` via its leading column, so a separate index\n    // would be pure write amplification.\n    const createDdl = [\n      `CREATE TABLE IF NOT EXISTS ${name} (\n  \"graph_id\" TEXT NOT NULL,\n  \"node_id\" TEXT NOT NULL,\n  \"embedding\" vector(${slot.dimensions}) NOT NULL,\n  \"created_at\" TIMESTAMPTZ NOT NULL,\n  \"updated_at\" TIMESTAMPTZ NOT NULL,\n  PRIMARY KEY (\"graph_id\", \"node_id\")\n);`,\n    ];\n\n    // The HNSW/IVFFlat index is intentionally NOT created here. pgvector\n    // similarity SQL is planner-driven (`ORDER BY embedding <=> q LIMIT k`\n    // uses the index when present, sequential-scans when not), so the index\n    // is a pure materialization concern: `buildCreateIndex` builds it through\n    // `materializeIndexes()` with the field's declared `m`/`ef_construction`/\n    // `lists`. Building it eagerly here would bake in default tuning (the\n    // write-ensure slot has no `indexParams`) and `CREATE INDEX IF NOT EXISTS`\n    // would then mask the tuned index materialization would emit.\n\n    return [\n      {\n        logicalName: `${VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,\n        owner: \"pgvector\",\n        tableName: table,\n        createDdl,\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(slot, params: UpsertEmbeddingParams, timestamp): readonly SQL[] {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    const value = vectorLiteral(params.embedding, \"embedding\");\n    return [\n      sql`\n        INSERT INTO ${table} (\"graph_id\", \"node_id\", \"embedding\", \"created_at\", \"updated_at\")\n        VALUES (${params.graphId}, ${params.nodeId}, ${value}, ${timestamp}, ${timestamp})\n        ON CONFLICT (\"graph_id\", \"node_id\")\n        DO UPDATE SET \"embedding\" = EXCLUDED.\"embedding\", \"updated_at\" = EXCLUDED.\"updated_at\"\n      `,\n    ];\n  },\n\n  buildDelete(slot, params: DeleteEmbeddingParams): readonly SQL[] {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    return [\n      sql`\n        DELETE FROM ${table}\n        WHERE \"graph_id\" = ${params.graphId} AND \"node_id\" = ${params.nodeId}\n      `,\n    ];\n  },\n\n  buildSearch(slot, params: VectorSearchParams): SQL {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    const embeddingColumn = sql`${table}.\"embedding\"`;\n    const distance = distanceExpression(\n      embeddingColumn,\n      params.queryEmbedding,\n      params.metric,\n    );\n    const score = vectorScoreExpression(distance, params.metric);\n\n    // Same SQL for brute-force and ANN: with a matching HNSW/IVFFlat index the\n    // Postgres planner rewrites this `ORDER BY distance LIMIT k` into an index\n    // scan automatically, so the strategy never branches on `slot.indexType`.\n    const conditions: SQL[] = [sql`${table}.\"graph_id\" = ${params.graphId}`];\n    if (params.minScore !== undefined) {\n      conditions.push(\n        vectorMinScoreCondition(distance, params.metric, params.minScore),\n      );\n    }\n    return sql`\n      SELECT ${table}.\"node_id\" AS node_id, ${score} AS score\n      FROM ${table}\n      WHERE ${sql.join(conditions, sql` AND `)}\n      ORDER BY ${distance} ASC\n      LIMIT ${params.limit}\n    `;\n  },\n\n  distanceExpression(embeddingColumn, queryEmbedding, metric) {\n    return distanceExpression(embeddingColumn, queryEmbedding, metric);\n  },\n\n  buildCreateIndex(slot, options): SQL | undefined {\n    if (!usesAnnIndex(slot)) return undefined;\n    return sql.raw(\n      pgvectorIndexDdl(\n        this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n        slot,\n        options?.concurrent === true,\n      ),\n    );\n  },\n\n  buildDropIndex(slot): SQL | undefined {\n    if (!usesAnnIndex(slot)) return undefined;\n    const indexName = pgvectorIndexName(slot);\n    return sql.raw(`DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);\n  },\n\n  buildDropStorage(slot): readonly string[] {\n    const table = quoteIdentifier(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    // CASCADE drops the ANN index along with the table.\n    return [`DROP TABLE IF EXISTS ${table} CASCADE`];\n  },\n};\n\nfunction pgvectorIndexName(slot: VectorSlot): string {\n  return vectorPhysicalName(\n    INDEX_PREFIX,\n    slot.graphId,\n    slot.nodeKind,\n    slot.fieldPath,\n  );\n}\n\nfunction pgvectorIndexDdl(\n  table: string,\n  slot: VectorSlot,\n  concurrent: boolean,\n): string {\n  const indexName = quoteIdentifier(pgvectorIndexName(slot));\n  const quotedTable = quoteIdentifier(table);\n  const opClass = operatorClass(slot.metric);\n  // Honor the field's declared tuning; fall back to pgvector defaults.\n  const m = slot.indexParams?.m ?? DEFAULT_HNSW_M;\n  const efConstruction =\n    slot.indexParams?.efConstruction ?? DEFAULT_HNSW_EF_CONSTRUCTION;\n  const lists = slot.indexParams?.lists ?? DEFAULT_IVFFLAT_LISTS;\n  // CONCURRENTLY builds without taking a write-blocking lock on the live table\n  // (materializeIndexes passes concurrent on Postgres). Run outside a tx.\n  const create = `CREATE INDEX${concurrent ? \" CONCURRENTLY\" : \"\"} IF NOT EXISTS`;\n\n  switch (slot.indexType) {\n    case \"hnsw\": {\n      return `${create} ${indexName} ON ${quotedTable} USING hnsw (\"embedding\" ${opClass}) WITH (m = ${m}, ef_construction = ${efConstruction});`;\n    }\n    case \"ivfflat\": {\n      return `${create} ${indexName} ON ${quotedTable} USING ivfflat (\"embedding\" ${opClass}) WITH (lists = ${lists});`;\n    }\n    case \"none\": {\n      throw new Error(\n        \"pgvectorIndexDdl called for a brute-force-only slot (indexType 'none').\",\n      );\n    }\n    default: {\n      const _exhaustive: never = slot.indexType;\n      throw new Error(`Unsupported vector index type: ${String(_exhaustive)}`);\n    }\n  }\n}\n","/**\n * Shared Compiler Utilities\n *\n * Functions and constants shared between the standard and recursive compilers.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { type AggregateExpr, type FieldRef, type SelectiveField } from \"../ast\";\n\n// ============================================================\n// Constants\n// ============================================================\n\nexport const NODE_COLUMNS = [\n  \"id\",\n  \"kind\",\n  \"props\",\n  \"version\",\n  \"valid_from\",\n  \"valid_to\",\n  \"created_at\",\n  \"updated_at\",\n  \"deleted_at\",\n] as const;\n\nexport const EDGE_COLUMNS = [\n  \"id\",\n  \"kind\",\n  \"from_id\",\n  \"to_id\",\n  \"props\",\n  \"valid_from\",\n  \"valid_to\",\n  \"created_at\",\n  \"updated_at\",\n  \"deleted_at\",\n] as const;\n\nexport type RequiredColumnsByAlias = ReadonlyMap<string, ReadonlySet<string>>;\nexport const EMPTY_REQUIRED_COLUMNS = new Set<string>();\n\n// ============================================================\n// SQL Helpers\n// ============================================================\n\nexport function quoteIdentifier(identifier: string): SQL {\n  return sql.raw(`\"${identifier.replaceAll('\"', '\"\"')}\"`);\n}\n\n// ============================================================\n// Column Projection\n// ============================================================\n\n/**\n * Determines whether a column should be included in the projection.\n *\n * @param requiredColumns - Set of columns required by the query, or undefined to include all.\n * @param column - The column name to check.\n * @param alwaysRequiredColumns - Optional set of columns that are always projected\n *   (e.g. join keys in recursive CTEs). Pass only from recursive compiler callers.\n */\nexport function shouldProjectColumn(\n  requiredColumns: ReadonlySet<string> | undefined,\n  column: string,\n  alwaysRequiredColumns?: ReadonlySet<string>,\n): boolean {\n  if (alwaysRequiredColumns?.has(column)) return true;\n  if (requiredColumns === undefined) return true;\n  return requiredColumns.has(column);\n}\n\n// ============================================================\n// Required Column Tracking\n// ============================================================\n\nexport function addRequiredColumn(\n  requiredColumnsByAlias: Map<string, Set<string>>,\n  alias: string,\n  column: string,\n): void {\n  const existing = requiredColumnsByAlias.get(alias);\n  if (existing) {\n    existing.add(column);\n    return;\n  }\n  requiredColumnsByAlias.set(alias, new Set([column]));\n}\n\nexport function markFieldRefAsRequired(\n  requiredColumnsByAlias: Map<string, Set<string>>,\n  field: FieldRef,\n): void {\n  const column = field.path[0];\n  if (column === undefined) return;\n  addRequiredColumn(requiredColumnsByAlias, field.alias, column);\n}\n\nexport function mapSelectiveSystemFieldToColumn(field: string): string {\n  if (field === \"fromId\") return \"from_id\";\n  if (field === \"toId\") return \"to_id\";\n  if (field.startsWith(\"meta.\")) {\n    return field\n      .slice(5)\n      .replaceAll(/([A-Z])/g, \"_$1\")\n      .toLowerCase();\n  }\n  return field;\n}\n\nexport function markSelectiveFieldAsRequired(\n  requiredColumnsByAlias: Map<string, Set<string>>,\n  field: SelectiveField,\n): void {\n  if (field.isSystemField) {\n    addRequiredColumn(\n      requiredColumnsByAlias,\n      field.alias,\n      mapSelectiveSystemFieldToColumn(field.field),\n    );\n    return;\n  }\n  addRequiredColumn(requiredColumnsByAlias, field.alias, \"props\");\n}\n\n// ============================================================\n// AST Type Guards\n// ============================================================\n\nexport function isIdFieldRef(field: FieldRef): boolean {\n  return (\n    field.path.length === 1 &&\n    field.path[0] === \"id\" &&\n    field.jsonPointer === undefined\n  );\n}\n\nexport function isAggregateExpr(\n  source: FieldRef | AggregateExpr,\n): source is AggregateExpr {\n  return \"__type\" in source && source.__type === \"aggregate\";\n}\n"]}