@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/chunk-KNHYNQQ3.cjs

@@ -1,663 +0,0 @@
-'use strict';
-
-var chunkN6WTUSBV_cjs = require('./chunk-N6WTUSBV.cjs');
-var chunkT6SPUYLX_cjs = require('./chunk-T6SPUYLX.cjs');
-var chunk5IQIX7LU_cjs = require('./chunk-5IQIX7LU.cjs');
-var chunkUNNPKQUG_cjs = require('./chunk-UNNPKQUG.cjs');
-var chunkYC6PWTHY_cjs = require('./chunk-YC6PWTHY.cjs');
-var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
-var zod = require('zod');
-
-var FORMAT_VERSION = "1.0";
-var ValidityTimestampSchema = zod.z.iso.datetime().refine((value) => chunkYC6PWTHY_cjs.isCanonicalIsoDate(value), {
-  message: "Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString()."
-});
-var InterchangeNodeSchema = zod.z.object({
-  kind: zod.z.string().min(1),
-  id: zod.z.string().min(1),
-  properties: zod.z.record(zod.z.string(), zod.z.unknown()),
-  validFrom: ValidityTimestampSchema.optional(),
-  validTo: ValidityTimestampSchema.optional(),
-  meta: zod.z.object({
-    version: zod.z.number().int().positive().optional(),
-    createdAt: zod.z.iso.datetime().optional(),
-    updatedAt: zod.z.iso.datetime().optional()
-  }).optional()
-});
-var InterchangeEdgeSchema = zod.z.object({
-  kind: zod.z.string().min(1),
-  id: zod.z.string().min(1),
-  from: zod.z.object({
-    kind: zod.z.string().min(1),
-    id: zod.z.string().min(1)
-  }),
-  to: zod.z.object({
-    kind: zod.z.string().min(1),
-    id: zod.z.string().min(1)
-  }),
-  properties: zod.z.record(zod.z.string(), zod.z.unknown()).default({}),
-  validFrom: ValidityTimestampSchema.optional(),
-  validTo: ValidityTimestampSchema.optional(),
-  meta: zod.z.object({
-    createdAt: zod.z.iso.datetime().optional(),
-    updatedAt: zod.z.iso.datetime().optional()
-  }).optional()
-});
-var ConflictStrategySchema = zod.z.enum(["skip", "update", "error"]);
-var UnknownPropertyStrategySchema = zod.z.enum([
-  "error",
-  "strip",
-  "allow"
-]);
-var ImportOptionsSchema = zod.z.object({
-  /** How to handle existing nodes/edges with the same ID */
-  onConflict: ConflictStrategySchema,
-  /** How to handle properties not in the schema */
-  onUnknownProperty: UnknownPropertyStrategySchema.default("error"),
-  /** Whether to validate that edge endpoints exist */
-  validateReferences: zod.z.boolean().default(true),
-  /** Number of items to process in each batch */
-  batchSize: zod.z.number().int().positive().default(100)
-});
-var GraphDataSourceSchema = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    type: zod.z.literal("typegraph-export"),
-    graphId: zod.z.string(),
-    schemaVersion: zod.z.number().int().positive()
-  }),
-  zod.z.object({
-    type: zod.z.literal("external"),
-    description: zod.z.string().optional()
-  })
-]);
-var GraphDataSchema = zod.z.object({
-  formatVersion: zod.z.literal(FORMAT_VERSION),
-  exportedAt: zod.z.iso.datetime(),
-  source: GraphDataSourceSchema,
-  nodes: zod.z.array(InterchangeNodeSchema),
-  edges: zod.z.array(InterchangeEdgeSchema)
-});
-var ImportErrorSchema = zod.z.object({
-  entityType: zod.z.enum(["node", "edge"]),
-  kind: zod.z.string(),
-  id: zod.z.string(),
-  error: zod.z.string()
-});
-var ImportResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  nodes: zod.z.object({
-    created: zod.z.number().int().nonnegative(),
-    updated: zod.z.number().int().nonnegative(),
-    skipped: zod.z.number().int().nonnegative()
-  }),
-  edges: zod.z.object({
-    created: zod.z.number().int().nonnegative(),
-    updated: zod.z.number().int().nonnegative(),
-    skipped: zod.z.number().int().nonnegative()
-  }),
-  errors: zod.z.array(ImportErrorSchema)
-});
-var ExportOptionsSchema = zod.z.object({
-  /** Filter to specific node kinds (undefined = all) */
-  nodeKinds: zod.z.array(zod.z.string()).optional(),
-  /** Filter to specific edge kinds (undefined = all) */
-  edgeKinds: zod.z.array(zod.z.string()).optional(),
-  /** Include temporal fields (validFrom, validTo) */
-  includeTemporal: zod.z.boolean().default(false),
-  /** Include metadata (version, timestamps) */
-  includeMeta: zod.z.boolean().default(false),
-  /** Include soft-deleted records */
-  includeDeleted: zod.z.boolean().default(false)
-});
-
-// src/interchange/export.ts
-async function exportGraph(store, options) {
-  const options_ = {
-    nodeKinds: options?.nodeKinds,
-    edgeKinds: options?.edgeKinds,
-    includeTemporal: options?.includeTemporal ?? false,
-    includeMeta: options?.includeMeta ?? false,
-    includeDeleted: options?.includeDeleted ?? false
-  };
-  const graph = store.graph;
-  const graphId = store.graphId;
-  const backend = store.backend;
-  const nodeKindsToExport = options_.nodeKinds ?? chunkT6SPUYLX_cjs.getNodeKinds(graph);
-  const edgeKindsToExport = options_.edgeKinds ?? chunkT6SPUYLX_cjs.getEdgeKinds(graph);
-  const nodes = [];
-  for (const kind of nodeKindsToExport) {
-    const kindNodes = await exportNodesOfKind(backend, graphId, kind, options_);
-    nodes.push(...kindNodes);
-  }
-  const edges = [];
-  for (const kind of edgeKindsToExport) {
-    const kindEdges = await exportEdgesOfKind(backend, graphId, kind, options_);
-    edges.push(...kindEdges);
-  }
-  const schemaVersion = await backend.getActiveSchema(graphId);
-  return {
-    formatVersion: FORMAT_VERSION,
-    exportedAt: chunkYC6PWTHY_cjs.nowIso(),
-    source: {
-      type: "typegraph-export",
-      graphId,
-      schemaVersion: schemaVersion?.version ?? 1
-    },
-    nodes,
-    edges
-  };
-}
-async function exportNodesOfKind(backend, graphId, kind, options) {
-  const rows = await backend.findNodesByKind({
-    graphId,
-    kind,
-    excludeDeleted: !options.includeDeleted
-  });
-  return rows.map((row) => {
-    const node = {
-      kind: row.kind,
-      id: row.id,
-      properties: JSON.parse(row.props)
-    };
-    if (options.includeTemporal) {
-      if (row.valid_from) {
-        node.validFrom = row.valid_from;
-      }
-      if (row.valid_to) {
-        node.validTo = row.valid_to;
-      }
-    }
-    if (options.includeMeta) {
-      node.meta = {
-        version: row.version,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    }
-    return node;
-  });
-}
-async function exportEdgesOfKind(backend, graphId, kind, options) {
-  const rows = await backend.findEdgesByKind({
-    graphId,
-    kind,
-    excludeDeleted: !options.includeDeleted
-  });
-  return rows.map((row) => {
-    const edge = {
-      kind: row.kind,
-      id: row.id,
-      from: {
-        kind: row.from_kind,
-        id: row.from_id
-      },
-      to: {
-        kind: row.to_kind,
-        id: row.to_id
-      },
-      properties: JSON.parse(row.props)
-    };
-    if (options.includeTemporal) {
-      if (row.valid_from) {
-        edge.validFrom = row.valid_from;
-      }
-      if (row.valid_to) {
-        edge.validTo = row.valid_to;
-      }
-    }
-    if (options.includeMeta) {
-      edge.meta = {
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    }
-    return edge;
-  });
-}
-
-// src/interchange/import.ts
-async function importGraph(store, data, options) {
-  const result = {
-    success: true,
-    nodes: { created: 0, updated: 0, skipped: 0 },
-    edges: { created: 0, updated: 0, skipped: 0 },
-    errors: []
-  };
-  const errors = [];
-  const graph = store.graph;
-  const graphId = store.graphId;
-  const backend = store.backend;
-  const registry = store.registry;
-  const nodeSchemas = buildNodeSchemaMap(graph);
-  const edgeSchemas = buildEdgeSchemaMap(graph);
-  const importedNodeIds = /* @__PURE__ */ new Set();
-  await chunkN6WTUSBV_cjs.runInWriteTransaction(store, backend, async (target, lock) => {
-    await processNodes(
-      target,
-      graphId,
-      registry,
-      data.nodes,
-      nodeSchemas,
-      options,
-      result,
-      errors,
-      importedNodeIds,
-      lock
-    );
-    await processEdges(
-      target,
-      graphId,
-      registry,
-      data.edges,
-      edgeSchemas,
-      nodeSchemas,
-      options,
-      result,
-      errors,
-      importedNodeIds
-    );
-  });
-  return {
-    ...result,
-    success: errors.length === 0,
-    errors
-  };
-}
-function buildNodeSchemaMap(graph) {
-  const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkT6SPUYLX_cjs.getNodeKinds(graph)) {
-    const registration = graph.nodes[kindName];
-    map.set(kindName, {
-      registration,
-      schema: registration.type.schema
-    });
-  }
-  return map;
-}
-function buildEdgeSchemaMap(graph) {
-  const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkT6SPUYLX_cjs.getEdgeKinds(graph)) {
-    const registration = graph.edges[kindName];
-    map.set(kindName, {
-      registration,
-      schema: registration.type.schema
-    });
-  }
-  return map;
-}
-async function processNodes(backend, graphId, registry, nodes, schemas, options, result, errors, importedNodeIds, lock) {
-  const batchSize = options.batchSize;
-  for (let index = 0; index < nodes.length; index += batchSize) {
-    const batch = nodes.slice(index, index + batchSize);
-    for (const node of batch) {
-      const importResult = await processNode(
-        backend,
-        graphId,
-        registry,
-        node,
-        schemas,
-        options,
-        lock
-      );
-      switch (importResult.status) {
-        case "created": {
-          result.nodes.created++;
-          importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          break;
-        }
-        case "updated": {
-          result.nodes.updated++;
-          importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          break;
-        }
-        case "skipped": {
-          result.nodes.skipped++;
-          if (importResult.liveTarget) {
-            importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          }
-          break;
-        }
-        case "error": {
-          errors.push({
-            entityType: "node",
-            kind: node.kind,
-            id: node.id,
-            error: importResult.error
-          });
-          break;
-        }
-      }
-    }
-  }
-}
-async function catchUniquenessError(fn) {
-  try {
-    return { ok: true, value: await fn() };
-  } catch (error) {
-    if (error instanceof chunkJIEJCTDS_cjs.UniquenessError) {
-      return { ok: false, error: error.message };
-    }
-    throw error;
-  }
-}
-function validateValidityWindow(entity) {
-  try {
-    chunkYC6PWTHY_cjs.validateOptionalCanonicalIsoDate(entity.validFrom, "validFrom");
-    chunkYC6PWTHY_cjs.validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
-    return void 0;
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-}
-async function processNode(backend, graphId, registry, node, schemas, options, lock) {
-  const schemaEntry = schemas.get(node.kind);
-  if (!schemaEntry) {
-    return { status: "error", error: `Unknown node kind: ${node.kind}` };
-  }
-  const propsResult = validateProperties(
-    node.properties,
-    schemaEntry.schema,
-    options.onUnknownProperty
-  );
-  if (!propsResult.success) {
-    return { status: "error", error: propsResult.error };
-  }
-  const validityError = validateValidityWindow(node);
-  if (validityError !== void 0) {
-    return { status: "error", error: validityError };
-  }
-  const { registration } = schemaEntry;
-  const uniqueConstraints = registration.unique ?? [];
-  const writeContext = { graphId, registry, lock };
-  const existing = await backend.getNode(graphId, node.kind, node.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return { status: "skipped", liveTarget: chunkUNNPKQUG_cjs.isLiveNodeRow(existing) };
-      }
-      case "error": {
-        return {
-          status: "error",
-          error: `Node already exists: ${node.kind}:${node.id}`
-        };
-      }
-      case "update": {
-        if (!chunkUNNPKQUG_cjs.isLiveNodeRow(existing)) {
-          return { status: "skipped", liveTarget: false };
-        }
-        const updateResult = await catchUniquenessError(
-          () => chunk5IQIX7LU_cjs.applyNodeUpdate(
-            writeContext,
-            {
-              existing,
-              schema: registration.type.schema,
-              validatedProps: propsResult.data,
-              uniqueConstraints,
-              ...node.validTo !== void 0 && { validTo: node.validTo }
-            },
-            backend
-          )
-        );
-        if (!updateResult.ok) {
-          return { status: "error", error: updateResult.error };
-        }
-        return { status: "updated" };
-      }
-    }
-  }
-  const uniquenessResult = await catchUniquenessError(
-    () => chunk5IQIX7LU_cjs.checkUniquenessConstraints(
-      { graphId, registry, backend },
-      node.kind,
-      node.id,
-      propsResult.data,
-      uniqueConstraints
-    )
-  );
-  if (!uniquenessResult.ok) {
-    return { status: "error", error: uniquenessResult.error };
-  }
-  await backend.insertNode({
-    graphId,
-    kind: node.kind,
-    id: node.id,
-    props: propsResult.data,
-    ...node.validFrom !== void 0 && { validFrom: node.validFrom },
-    ...node.validTo !== void 0 && { validTo: node.validTo }
-  });
-  await chunk5IQIX7LU_cjs.applyNodeInsertSideEffects(
-    writeContext,
-    {
-      kind: node.kind,
-      id: node.id,
-      schema: registration.type.schema,
-      props: propsResult.data,
-      uniqueConstraints
-    },
-    backend
-  );
-  return { status: "created" };
-}
-async function processEdges(backend, graphId, registry, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
-  const batchSize = options.batchSize;
-  for (let index = 0; index < edges.length; index += batchSize) {
-    const batch = edges.slice(index, index + batchSize);
-    for (const edge of batch) {
-      const importResult = await processEdge(
-        backend,
-        graphId,
-        registry,
-        edge,
-        edgeSchemas,
-        nodeSchemas,
-        options,
-        importedNodeIds
-      );
-      switch (importResult.status) {
-        case "created": {
-          result.edges.created++;
-          break;
-        }
-        case "updated": {
-          result.edges.updated++;
-          break;
-        }
-        case "skipped": {
-          result.edges.skipped++;
-          break;
-        }
-        case "error": {
-          errors.push({
-            entityType: "edge",
-            kind: edge.kind,
-            id: edge.id,
-            error: importResult.error
-          });
-          break;
-        }
-      }
-    }
-  }
-}
-async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
-  const schemaEntry = edgeSchemas.get(edge.kind);
-  if (!schemaEntry) {
-    return { status: "error", error: `Unknown edge kind: ${edge.kind}` };
-  }
-  if (!nodeSchemas.has(edge.from.kind)) {
-    return {
-      status: "error",
-      error: `Unknown from node kind: ${edge.from.kind}`
-    };
-  }
-  if (!nodeSchemas.has(edge.to.kind)) {
-    return { status: "error", error: `Unknown to node kind: ${edge.to.kind}` };
-  }
-  const endpointError = chunk5IQIX7LU_cjs.validateEdgeEndpoints(
-    edge.kind,
-    edge.from.kind,
-    edge.to.kind,
-    schemaEntry.registration,
-    registry
-  );
-  if (endpointError !== void 0) {
-    return { status: "error", error: endpointError.message };
-  }
-  if (options.validateReferences) {
-    const fromKey = makeNodeKey(edge.from.kind, edge.from.id);
-    const toKey = makeNodeKey(edge.to.kind, edge.to.id);
-    if (!importedNodeIds.has(fromKey)) {
-      const fromExists = await backend.getNode(
-        graphId,
-        edge.from.kind,
-        edge.from.id
-      );
-      if (fromExists === void 0 || !chunkUNNPKQUG_cjs.isLiveNodeRow(fromExists)) {
-        return {
-          status: "error",
-          error: `From node not found: ${edge.from.kind}:${edge.from.id}`
-        };
-      }
-    }
-    if (!importedNodeIds.has(toKey)) {
-      const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);
-      if (toExists === void 0 || !chunkUNNPKQUG_cjs.isLiveNodeRow(toExists)) {
-        return {
-          status: "error",
-          error: `To node not found: ${edge.to.kind}:${edge.to.id}`
-        };
-      }
-    }
-  }
-  const propsResult = validateProperties(
-    edge.properties,
-    schemaEntry.schema,
-    options.onUnknownProperty
-  );
-  if (!propsResult.success) {
-    return { status: "error", error: propsResult.error };
-  }
-  const validityError = validateValidityWindow(edge);
-  if (validityError !== void 0) {
-    return { status: "error", error: validityError };
-  }
-  const existing = await backend.getEdge(graphId, edge.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return {
-          status: "skipped",
-          liveTarget: existing.deleted_at === void 0
-        };
-      }
-      case "error": {
-        return { status: "error", error: `Edge already exists: ${edge.id}` };
-      }
-      case "update": {
-        if (existing.deleted_at !== void 0) {
-          return { status: "skipped", liveTarget: false };
-        }
-        await backend.updateEdge({
-          graphId,
-          id: edge.id,
-          props: propsResult.data,
-          ...edge.validTo !== void 0 && { validTo: edge.validTo }
-        });
-        return { status: "updated" };
-      }
-    }
-  }
-  await backend.insertEdge({
-    graphId,
-    id: edge.id,
-    kind: edge.kind,
-    fromKind: edge.from.kind,
-    fromId: edge.from.id,
-    toKind: edge.to.kind,
-    toId: edge.to.id,
-    props: propsResult.data,
-    ...edge.validFrom !== void 0 && { validFrom: edge.validFrom },
-    ...edge.validTo !== void 0 && { validTo: edge.validTo }
-  });
-  return { status: "created" };
-}
-function validateProperties(properties, schema, unknownStrategy) {
-  try {
-    const knownKeys = new Set(Object.keys(schema.shape));
-    const unknownKeys = Object.keys(properties).filter(
-      (key) => !knownKeys.has(key)
-    );
-    if (unknownKeys.length > 0) {
-      switch (unknownStrategy) {
-        case "error": {
-          return {
-            success: false,
-            error: `Unknown properties: ${unknownKeys.join(", ")}`
-          };
-        }
-        case "strip": {
-          const stripped = {};
-          for (const key of knownKeys) {
-            if (key in properties) {
-              stripped[key] = properties[key];
-            }
-          }
-          const result2 = schema.safeParse(stripped);
-          if (!result2.success) {
-            return {
-              success: false,
-              error: formatZodError(result2.error)
-            };
-          }
-          return {
-            success: true,
-            data: result2.data
-          };
-        }
-        case "allow": {
-          const result2 = schema.safeParse(properties);
-          if (!result2.success) {
-            return {
-              success: false,
-              error: formatZodError(result2.error)
-            };
-          }
-          return { success: true, data: properties };
-        }
-      }
-    }
-    const result = schema.safeParse(properties);
-    if (!result.success) {
-      return { success: false, error: formatZodError(result.error) };
-    }
-    return { success: true, data: result.data };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, error: `Validation error: ${message}` };
-  }
-}
-function formatZodError(error) {
-  return error.issues.map((issue) => {
-    const path = issue.path.join(".");
-    return path ? `${path}: ${issue.message}` : issue.message;
-  }).join("; ");
-}
-function makeNodeKey(kind, id) {
-  return `${kind}:${id}`;
-}
-
-exports.ConflictStrategySchema = ConflictStrategySchema;
-exports.ExportOptionsSchema = ExportOptionsSchema;
-exports.FORMAT_VERSION = FORMAT_VERSION;
-exports.GraphDataSchema = GraphDataSchema;
-exports.GraphDataSourceSchema = GraphDataSourceSchema;
-exports.ImportErrorSchema = ImportErrorSchema;
-exports.ImportOptionsSchema = ImportOptionsSchema;
-exports.ImportResultSchema = ImportResultSchema;
-exports.InterchangeEdgeSchema = InterchangeEdgeSchema;
-exports.InterchangeNodeSchema = InterchangeNodeSchema;
-exports.UnknownPropertyStrategySchema = UnknownPropertyStrategySchema;
-exports.exportGraph = exportGraph;
-exports.importGraph = importGraph;
-//# sourceMappingURL=chunk-KNHYNQQ3.cjs.map
-//# sourceMappingURL=chunk-KNHYNQQ3.cjs.map