@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/{chunk-PYD3UCDU.js → chunk-JBTOYDMN.js}

@@ -1,8 +1,186 @@
-import { resolveFieldTypeInfoAtJsonPointer } from './chunk-XLUNB2TZ.js';
-import { UnsupportedPredicateError, CompilerInvariantError, DatabaseOperationError } from './chunk-TQOYM4LN.js';
-import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-K5P5OZXS.js';
+import { nowIso } from './chunk-I7ZUZKFD.js';
+import { likeEscapeClause, LIKE_ESCAPE_CHARACTER } from './chunk-OHMP6N2J.js';
+import { resolveFieldTypeInfoAtJsonPointer } from './chunk-SNXVDZAJ.js';
+import { ConfigurationError, UnsupportedPredicateError, CompilerInvariantError } from './chunk-MP2JQKSG.js';
+import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-G6Q5UM7U.js';
 import { sql } from 'drizzle-orm';
 
+// src/backend/types.ts
+function rowPropsToObject(props) {
+  return typeof props === "string" ? JSON.parse(props) : props;
+}
+function rowPropsToJsonText(props) {
+  return typeof props === "string" ? props : JSON.stringify(props);
+}
+function isLiveNodeRow(row) {
+  return row.deleted_at === void 0;
+}
+function isTombstonedNodeRow(row) {
+  return row.deleted_at !== void 0;
+}
+function createBackendOverlay(target, overlay) {
+  const boundTargetMethods = /* @__PURE__ */ new Map();
+  function hasOverlayProperty(property) {
+    return Object.hasOwn(overlay, property);
+  }
+  function targetValue(targetObject, property) {
+    const value = Reflect.get(targetObject, property, targetObject);
+    if (typeof value !== "function") return value;
+    const cached = boundTargetMethods.get(property);
+    if (cached !== void 0) return cached;
+    const method = value;
+    const bound = method.bind(targetObject);
+    boundTargetMethods.set(property, bound);
+    return bound;
+  }
+  return new Proxy(target, {
+    get(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.get(overlay, property, overlay);
+      }
+      return targetValue(targetObject, property);
+    },
+    has(targetObject, property) {
+      return hasOverlayProperty(property) || Reflect.has(targetObject, property);
+    },
+    ownKeys(targetObject) {
+      return [
+        .../* @__PURE__ */ new Set([
+          ...Reflect.ownKeys(targetObject),
+          ...Reflect.ownKeys(overlay)
+        ])
+      ];
+    },
+    getOwnPropertyDescriptor(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(overlay, property);
+        if (descriptor === void 0) return;
+        return { ...descriptor, configurable: true };
+      }
+      return Reflect.getOwnPropertyDescriptor(targetObject, property);
+    },
+    set(targetObject, property, value) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.set(overlay, property, value, overlay);
+      }
+      return Reflect.set(targetObject, property, value, targetObject);
+    },
+    defineProperty(targetObject, property, attributes) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.defineProperty(overlay, property, attributes);
+      }
+      return Reflect.defineProperty(targetObject, property, attributes);
+    },
+    deleteProperty(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.deleteProperty(overlay, property);
+      }
+      return Reflect.deleteProperty(targetObject, property);
+    }
+  });
+}
+function wrapWithManagedClose(backend, teardown) {
+  let isClosed = false;
+  return createBackendOverlay(backend, {
+    async close() {
+      if (isClosed) return;
+      isClosed = true;
+      await backend.close();
+      await teardown();
+    }
+  });
+}
+async function runOptionallyInTransaction(backend, fn, fallback) {
+  if ("transaction" in backend && backend.capabilities.transactions) {
+    return backend.transaction((tx) => fn(tx));
+  }
+  return fn(fallback ?? backend);
+}
+var SQLITE_MAX_BIND_PARAMETERS = 999;
+var MODERN_SQLITE_MAX_BIND_PARAMETERS = 32766;
+var D1_MAX_BIND_PARAMETERS = 100;
+var POSTGRES_MAX_BIND_PARAMETERS = 65535;
+var SQLITE_CAPABILITIES = {
+  transactions: true,
+  // SQLite supports transactions
+  windowFunctions: true,
+  // SQLite has supported window functions since 3.25.0
+  returning: true,
+  // SQLite has supported RETURNING since 3.35.0
+  maxBindParameters: SQLITE_MAX_BIND_PARAMETERS
+};
+var POSTGRES_CAPABILITIES = {
+  transactions: true,
+  // PostgreSQL supports transactions
+  windowFunctions: true,
+  // PostgreSQL supports ROW_NUMBER() and related windows
+  returning: true,
+  // PostgreSQL has supported RETURNING since 8.2
+  maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS
+};
+var pinnedReadInstant;
+function withPinnedReadInstant(emit) {
+  if (pinnedReadInstant !== void 0) return emit();
+  pinnedReadInstant = nowIso();
+  try {
+    return emit();
+  } finally {
+    pinnedReadInstant = void 0;
+  }
+}
+function currentReadInstant() {
+  return sql`${pinnedReadInstant ?? nowIso()}`;
+}
+var CURRENT_READ_INSTANT_PLACEHOLDER = "__typegraph_current_read_instant__";
+function currentReadInstantPlaceholder() {
+  return sql`${sql.placeholder(CURRENT_READ_INSTANT_PLACEHOLDER)}`;
+}
+function currentReadInstantFor(mode) {
+  return mode === "placeholder" ? currentReadInstantPlaceholder() : currentReadInstant();
+}
+function compileTemporalFilter(options) {
+  const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = options;
+  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
+  const deletedAt = sql`${prefix}deleted_at`;
+  const validFrom = sql`${prefix}valid_from`;
+  const validTo = sql`${prefix}valid_to`;
+  const validFilter = (() => {
+    switch (mode) {
+      case "current": {
+        const now = recordedAsOf === void 0 ? currentTimestamp ?? currentReadInstant() : sql`${recordedAsOf}`;
+        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
+      }
+      case "asOf": {
+        if (asOf === void 0) {
+          throw new Error(
+            `asOf timestamp is required for temporal mode "asOf"`
+          );
+        }
+        const timestamp = asOf;
+        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
+      }
+      case "includeEnded": {
+        return sql`${deletedAt} IS NULL`;
+      }
+      case "includeTombstones": {
+        return sql.raw("1=1");
+      }
+    }
+  })();
+  if (recordedAsOf === void 0) return validFilter;
+  const recordedFrom = sql`${prefix}recorded_from`;
+  const recordedTo = sql`${prefix}recorded_to`;
+  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedAsOf} AND ${recordedAsOf} < ${recordedTo}`;
+}
+function extractTemporalOptions(ast, tableAlias) {
+  return {
+    mode: ast.temporalMode.mode,
+    asOf: ast.temporalMode.asOf,
+    recordedAsOf: ast.recordedAsOf,
+    tableAlias
+  };
+}
+
 // src/query/subquery-utils.ts
 function normalizeValueType(valueType) {
   if (valueType === void 0 || valueType === "unknown") {
@@ -79,6 +257,12 @@ function predicate(expr) {
   };
 }
 function param(name) {
+  if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {
+    throw new ConfigurationError(
+      `Parameter name "${name}" is reserved for internal use`,
+      { parameterName: name }
+    );
+  }
   return { __type: "parameter", name };
 }
 function isParameterRef(value) {
@@ -311,7 +495,10 @@ function vectorSimilarity(field, queryEmbedding, limit, options) {
     // here would mis-rank l2/inner_product fields and bypass their ANN index.
     ...options?.metric !== void 0 && { metric: options.metric },
     limit,
-    ...options?.minScore !== void 0 && { minScore: options.minScore }
+    ...options?.minScore !== void 0 && { minScore: options.minScore },
+    ...options?.approximate !== void 0 && {
+      approximate: options.approximate
+    }
   };
   return predicate(expr);
 }
@@ -538,106 +725,6 @@ function assertCompatibleSubqueryValueTypes(field, subquery) {
     }
   );
 }
-
-// src/backend/types.ts
-function createBackendOverlay(target, overlay) {
-  const boundTargetMethods = /* @__PURE__ */ new Map();
-  function hasOverlayProperty(property) {
-    return Object.hasOwn(overlay, property);
-  }
-  function targetValue(targetObject, property) {
-    const value = Reflect.get(targetObject, property, targetObject);
-    if (typeof value !== "function") return value;
-    const cached = boundTargetMethods.get(property);
-    if (cached !== void 0) return cached;
-    const method = value;
-    const bound = method.bind(targetObject);
-    boundTargetMethods.set(property, bound);
-    return bound;
-  }
-  return new Proxy(target, {
-    get(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.get(overlay, property, overlay);
-      }
-      return targetValue(targetObject, property);
-    },
-    has(targetObject, property) {
-      return hasOverlayProperty(property) || Reflect.has(targetObject, property);
-    },
-    ownKeys(targetObject) {
-      return [
-        .../* @__PURE__ */ new Set([
-          ...Reflect.ownKeys(targetObject),
-          ...Reflect.ownKeys(overlay)
-        ])
-      ];
-    },
-    getOwnPropertyDescriptor(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(overlay, property);
-        if (descriptor === void 0) return;
-        return { ...descriptor, configurable: true };
-      }
-      return Reflect.getOwnPropertyDescriptor(targetObject, property);
-    },
-    set(targetObject, property, value) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.set(overlay, property, value, overlay);
-      }
-      return Reflect.set(targetObject, property, value, targetObject);
-    },
-    defineProperty(targetObject, property, attributes) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.defineProperty(overlay, property, attributes);
-      }
-      return Reflect.defineProperty(targetObject, property, attributes);
-    },
-    deleteProperty(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.deleteProperty(overlay, property);
-      }
-      return Reflect.deleteProperty(targetObject, property);
-    }
-  });
-}
-function wrapWithManagedClose(backend, teardown) {
-  let isClosed = false;
-  return createBackendOverlay(backend, {
-    async close() {
-      if (isClosed) return;
-      isClosed = true;
-      await backend.close();
-      await teardown();
-    }
-  });
-}
-async function runOptionallyInTransaction(backend, fn, fallback) {
-  if ("transaction" in backend && backend.capabilities.transactions) {
-    return backend.transaction((tx) => fn(tx));
-  }
-  return fn(fallback ?? backend);
-}
-var SQLITE_MAX_BIND_PARAMETERS = 999;
-var POSTGRES_MAX_BIND_PARAMETERS = 65535;
-var SQLITE_CAPABILITIES = {
-  transactions: true,
-  // SQLite supports transactions
-  windowFunctions: true,
-  // SQLite has supported window functions since 3.25.0
-  returning: true,
-  // SQLite has supported RETURNING since 3.35.0
-  maxBindParameters: SQLITE_MAX_BIND_PARAMETERS
-};
-var POSTGRES_CAPABILITIES = {
-  transactions: true,
-  // PostgreSQL supports transactions
-  windowFunctions: true,
-  // PostgreSQL supports ROW_NUMBER() and related windows
-  returning: true,
-  // PostgreSQL has supported RETURNING since 8.2
-  maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS
-};
 var COMPARISON_OP_SQL = {
   eq: "=",
   neq: "!=",
@@ -787,7 +874,10 @@ function convertValueForSql(value, dialect) {
   return dialect.bindValue(value);
 }
 function compileStringPattern(op, pattern) {
-  const escaped = pattern.replaceAll("%", String.raw`\%`).replaceAll("_", String.raw`\_`);
+  const escaped = pattern.replaceAll(
+    LIKE_ESCAPE_CHARACTER,
+    `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`
+  ).replaceAll("%", `${LIKE_ESCAPE_CHARACTER}%`).replaceAll("_", `${LIKE_ESCAPE_CHARACTER}_`);
   switch (op) {
     case "contains": {
       return `%${escaped}%`;
@@ -808,7 +898,8 @@ function compileStringPattern(op, pattern) {
   }
 }
 function escapeLikePatternParameter(parameter) {
-  return sql`REPLACE(REPLACE(REPLACE(${parameter}, '\\', '\\\\'), '%', '\\%'), '_', '\\_')`;
+  const doubledEscape = `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`;
+  return sql`REPLACE(REPLACE(REPLACE(${parameter}, ${LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${LIKE_ESCAPE_CHARACTER}_`})`;
 }
 function compileParameterizedStringPattern(op, parameter) {
   switch (op) {
@@ -854,13 +945,13 @@ function compilePredicateExpression(expr, ctx) {
         if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
           return dialect.ilike(field, pattern2);
         }
-        return sql`${field} LIKE ${pattern2}`;
+        return sql`${field} LIKE ${pattern2} ${likeEscapeClause}`;
       }
       const pattern = compileStringPattern(expr.op, expr.pattern);
       if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
         return dialect.ilike(field, pattern);
       }
-      return sql`${field} LIKE ${pattern}`;
+      return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;
     }
     case "null_check": {
       const field = compileFieldTextValue(
@@ -1306,146 +1397,6 @@ function getHybridTargetAlias(vectorPredicate, fulltextPredicate) {
   return vectorPredicate.field.alias === fulltextPredicate.field.alias ? vectorPredicate.field.alias : void 0;
 }
 
-// src/backend/drizzle/row-mappers.ts
-function requireTimestamp(value, field) {
-  if (value === void 0) {
-    throw new DatabaseOperationError(
-      `Expected non-null ${field} timestamp`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asString(value, field) {
-  if (typeof value !== "string") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be string, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asNumber(value, field) {
-  if (typeof value !== "number") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be number, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function nullToUndefined(value) {
-  return value ?? void 0;
-}
-function formatPostgresTimestamp(value) {
-  if (value === null || value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") {
-    if (value.includes("T")) return value;
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) return date.toISOString();
-    return value;
-  }
-  return void 0;
-}
-function coerceNumericScore(value) {
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(value);
-  if (Number.isNaN(parsed)) {
-    throw new TypeError(
-      `Backend returned non-numeric fulltext score: ${JSON.stringify(value)}`
-    );
-  }
-  return parsed;
-}
-function normalizeJsonColumn(value) {
-  return typeof value === "string" ? value : JSON.stringify(value ?? {});
-}
-var SQLITE_ROW_MAPPER_CONFIG = {
-  formatTimestamp: (value) => {
-    if (value === null || value === void 0) return;
-    if (typeof value !== "string") {
-      throw new DatabaseOperationError(
-        `Expected timestamp to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  },
-  normalizeJson: (value) => {
-    if (typeof value !== "string") {
-      throw new DatabaseOperationError(
-        `Expected JSON column to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  }
-};
-var POSTGRES_ROW_MAPPER_CONFIG = {
-  formatTimestamp: formatPostgresTimestamp,
-  normalizeJson: normalizeJsonColumn
-};
-function createNodeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    kind: asString(row.kind, "kind"),
-    id: asString(row.id, "id"),
-    props: config.normalizeJson(row.props),
-    version: asNumber(row.version, "version"),
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createEdgeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    id: asString(row.id, "id"),
-    kind: asString(row.kind, "kind"),
-    from_kind: asString(row.from_kind, "from_kind"),
-    from_id: asString(row.from_id, "from_id"),
-    to_kind: asString(row.to_kind, "to_kind"),
-    to_id: asString(row.to_id, "to_id"),
-    props: config.normalizeJson(row.props),
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createUniqueRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    node_kind: asString(row.node_kind, "node_kind"),
-    constraint_name: asString(row.constraint_name, "constraint_name"),
-    key: asString(row.key, "key"),
-    node_id: asString(row.node_id, "node_id"),
-    concrete_kind: asString(row.concrete_kind, "concrete_kind"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createSchemaVersionRowMapper(config) {
-  return (row) => {
-    const isActiveValue = row.is_active;
-    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
-    return {
-      graph_id: asString(row.graph_id, "graph_id"),
-      version: asNumber(row.version, "version"),
-      schema_hash: asString(row.schema_hash, "schema_hash"),
-      schema_doc: config.normalizeJson(row.schema_doc),
-      created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-      is_active: isActive
-    };
-  };
-}
-
 // src/utils/array.ts
 function chunk(items, size) {
   if (!Number.isSafeInteger(size) || size < 1) {
@@ -1475,6 +1426,6 @@ function isPresent(value) {
   return value !== null && value !== void 0;
 }
 
-export { POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, SQLITE_ROW_MAPPER_CONFIG, arrayField, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, chunk, coerceNumericScore, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, createBackendOverlay, createEdgeRowMapper, createFulltextAccessor, createNodeRowMapper, createSchemaVersionRowMapper, createUniqueRowMapper, dateField, exists, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, fieldRef, formatPostgresTimestamp, getHybridTargetAlias, getNodeKindsForAlias, getPredicatesForAlias, groupBy, inSubquery, isParameterRef, isPresent, notExists, notInSubquery, nowIso, numberField, objectField, param, runOptionallyInTransaction, sqlValueList, stringField, wrapWithManagedClose };
-//# sourceMappingURL=chunk-PYD3UCDU.js.map
-//# sourceMappingURL=chunk-PYD3UCDU.js.map
+export { CURRENT_READ_INSTANT_PLACEHOLDER, D1_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, arrayField, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, chunk, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, compileTemporalFilter, createBackendOverlay, createFulltextAccessor, currentReadInstant, currentReadInstantFor, dateField, exists, extractFulltextMatchPredicates, extractTemporalOptions, extractVectorSimilarityPredicates, fieldRef, getFieldPointer, getHybridTargetAlias, getNodeKindsForAlias, getPredicatesForAlias, groupBy, inSubquery, isLiveNodeRow, isParameterRef, isPresent, isTombstonedNodeRow, notExists, notInSubquery, numberField, objectField, param, rowPropsToJsonText, rowPropsToObject, runOptionallyInTransaction, sqlValueList, stringField, withPinnedReadInstant, wrapWithManagedClose };
+//# sourceMappingURL=chunk-JBTOYDMN.js.map
+//# sourceMappingURL=chunk-JBTOYDMN.js.map