@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/chunk-FA6Z7B5L.js

@@ -1,244 +0,0 @@
-import { typeGraphGlobalSymbol } from './chunk-QOJ2L2AD.js';
-
-// src/backend/transaction-resource.ts
-var SERIALIZED_TRANSACTION_RESOURCES = /* @__PURE__ */ new WeakMap();
-var ACTIVE_SERIALIZED_STREAMS = /* @__PURE__ */ new Map();
-function markSerializedTransactionResource(backend, resource) {
-  SERIALIZED_TRANSACTION_RESOURCES.set(backend, resource);
-}
-function inheritSerializedTransactionResource(target, source) {
-  const resource = SERIALIZED_TRANSACTION_RESOURCES.get(source);
-  if (resource !== void 0) {
-    SERIALIZED_TRANSACTION_RESOURCES.set(target, resource);
-  }
-}
-function sharesSerializedTransactionResource(left, right) {
-  const leftResource = SERIALIZED_TRANSACTION_RESOURCES.get(left);
-  return leftResource !== void 0 && leftResource === SERIALIZED_TRANSACTION_RESOURCES.get(right);
-}
-function snapshotExportContention(source, target) {
-  if (!source.capabilities.transactions) return void 0;
-  if (source === target && source.dialect === "sqlite") {
-    return "same-sqlite-backend";
-  }
-  if (sharesSerializedTransactionResource(source, target)) {
-    return "shared-resource";
-  }
-  return void 0;
-}
-function acquireSerializedStreamLease(backend, kind) {
-  const resource = SERIALIZED_TRANSACTION_RESOURCES.get(backend);
-  if (resource === void 0) {
-    return {
-      acquired: true,
-      release: () => {
-      }
-    };
-  }
-  const holder = ACTIVE_SERIALIZED_STREAMS.get(resource);
-  if (holder !== void 0) return { acquired: false, heldBy: holder };
-  ACTIVE_SERIALIZED_STREAMS.set(resource, kind);
-  let released = false;
-  return {
-    acquired: true,
-    release: () => {
-      if (released) return;
-      released = true;
-      ACTIVE_SERIALIZED_STREAMS.delete(resource);
-    }
-  };
-}
-
-// src/backend/types.ts
-function normalizeGraphAnalyticsCapabilities(capabilities) {
-  if (capabilities.graphAnalytics?.supported !== true || capabilities.transactions && capabilities.windowFunctions && capabilities.returning !== false) {
-    return capabilities;
-  }
-  return {
-    ...capabilities,
-    graphAnalytics: { ...capabilities.graphAnalytics, supported: false }
-  };
-}
-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;
-}
-var INTERNAL_TEMPORARY_WRITES = typeGraphGlobalSymbol(
-  "internal-temporary-writes-v1"
-);
-function createTransactionReadBackend(backend) {
-  const getNodes = backend.getNodes;
-  const getEdges = backend.getEdges;
-  const compileSql = backend.compileSql;
-  return Object.freeze({
-    dialect: backend.dialect,
-    capabilities: backend.capabilities,
-    ...backend.tableNames === void 0 ? {} : { tableNames: backend.tableNames },
-    ...backend.fulltextStrategy === void 0 ? {} : { fulltextStrategy: backend.fulltextStrategy },
-    ...backend.vectorStrategy === void 0 ? {} : { vectorStrategy: backend.vectorStrategy },
-    getNode: (graphId, kind, id) => backend.getNode(graphId, kind, id),
-    ...getNodes === void 0 ? {} : {
-      getNodes: (graphId, kind, ids) => getNodes(graphId, kind, ids)
-    },
-    getEdge: (graphId, id) => backend.getEdge(graphId, id),
-    ...getEdges === void 0 ? {} : {
-      getEdges: (graphId, ids) => getEdges(graphId, ids)
-    },
-    countEdgesFrom: (params) => backend.countEdgesFrom(params),
-    edgeExistsBetween: (params) => backend.edgeExistsBetween(params),
-    findEdgesConnectedTo: (params) => backend.findEdgesConnectedTo(params),
-    findNodesByKind: (params) => backend.findNodesByKind(params),
-    countNodesByKind: (params) => backend.countNodesByKind(params),
-    findEdgesByKind: (params) => backend.findEdgesByKind(params),
-    countEdgesByKind: (params) => backend.countEdgesByKind(params),
-    getActiveSchema: (graphId) => backend.getActiveSchema(graphId),
-    getSchemaVersion: (graphId, version) => backend.getSchemaVersion(graphId, version),
-    execute: (query) => backend.execute(query),
-    ...compileSql === void 0 ? {} : { compileSql: (query) => compileSql(query) }
-  });
-}
-function createBackendOverlay(target, overlay) {
-  function hasOverlayProperty(property) {
-    return Object.hasOwn(overlay, property);
-  }
-  const decoratedBackend = new Proxy(target, {
-    get(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.get(overlay, property, overlay);
-      }
-      return Reflect.get(targetObject, property, targetObject);
-    },
-    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);
-    }
-  });
-  inheritSerializedTransactionResource(decoratedBackend, target);
-  return decoratedBackend;
-}
-function wrapWithManagedClose(backend, teardown) {
-  let backendClosed = false;
-  let teardownComplete = false;
-  let closeInFlight;
-  async function closeManagedResources() {
-    const errors = [];
-    if (!backendClosed) {
-      try {
-        await backend.close();
-        backendClosed = true;
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (!teardownComplete) {
-      try {
-        await teardown();
-        teardownComplete = true;
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length === 1) throw errors[0];
-    if (errors.length > 1) {
-      throw new AggregateError(
-        errors,
-        "The backend and its managed resource both failed to close."
-      );
-    }
-  }
-  const closeOverlay = {
-    async close() {
-      if (backendClosed && teardownComplete) return;
-      closeInFlight ??= closeManagedResources().finally(() => {
-        closeInFlight = void 0;
-      });
-      await closeInFlight;
-    }
-  };
-  return createBackendOverlay(backend, closeOverlay);
-}
-async function closeAfterFailure(resource, provisioningError) {
-  try {
-    await resource.close();
-  } catch {
-  }
-  throw provisioningError;
-}
-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 DURABLE_OBJECT_MAX_BIND_PARAMETERS = 100;
-var POSTGRES_MAX_BIND_PARAMETERS = 65533;
-var SQLITE_CAPABILITIES = Object.freeze({
-  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,
-  // Generic SQLite builds do not guarantee ENABLE_MATH_FUNCTIONS. The local
-  // better-sqlite3 factory overrides this flag for its bundled build contract.
-  graphAnalytics: Object.freeze({ supported: true, mathFunctions: false })
-});
-var POSTGRES_CAPABILITIES = Object.freeze({
-  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,
-  graphAnalytics: Object.freeze({ supported: true, mathFunctions: true })
-});
-
-export { D1_MAX_BIND_PARAMETERS, DURABLE_OBJECT_MAX_BIND_PARAMETERS, INTERNAL_TEMPORARY_WRITES, MODERN_SQLITE_MAX_BIND_PARAMETERS, POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, acquireSerializedStreamLease, closeAfterFailure, createBackendOverlay, createTransactionReadBackend, inheritSerializedTransactionResource, isLiveNodeRow, isTombstonedNodeRow, markSerializedTransactionResource, normalizeGraphAnalyticsCapabilities, rowPropsToJsonText, rowPropsToObject, runOptionallyInTransaction, snapshotExportContention, wrapWithManagedClose };
-//# sourceMappingURL=chunk-FA6Z7B5L.js.map
-//# sourceMappingURL=chunk-FA6Z7B5L.js.map