@nicia-ai/typegraph 0.30.0 → 0.32.0

package/dist/interchange/index.cjs

@@ -1,606 +1,63 @@
 'use strict';
 
-var chunk7JGLPAFV_cjs = require('../chunk-7JGLPAFV.cjs');
+var chunkSB65GJNY_cjs = require('../chunk-SB65GJNY.cjs');
+require('../chunk-EEYV6UOE.cjs');
 require('../chunk-ZFWNO3GE.cjs');
 require('../chunk-JIEJCTDS.cjs');
-var zod = require('zod');
 
-var FORMAT_VERSION = "1.0";
-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: zod.z.iso.datetime().optional(),
-  validTo: zod.z.iso.datetime().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()
+
+
+Object.defineProperty(exports, "ConflictStrategySchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.ConflictStrategySchema; }
 });
-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: zod.z.iso.datetime().optional(),
-  validTo: zod.z.iso.datetime().optional(),
-  meta: zod.z.object({
-    createdAt: zod.z.iso.datetime().optional(),
-    updatedAt: zod.z.iso.datetime().optional()
-  }).optional()
+Object.defineProperty(exports, "ExportOptionsSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.ExportOptionsSchema; }
 });
-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)
+Object.defineProperty(exports, "FORMAT_VERSION", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.FORMAT_VERSION; }
 });
-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)
+Object.defineProperty(exports, "GraphDataSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.GraphDataSchema; }
 });
-var ImportErrorSchema = zod.z.object({
-  entityType: zod.z.enum(["node", "edge"]),
-  kind: zod.z.string(),
-  id: zod.z.string(),
-  error: zod.z.string()
+Object.defineProperty(exports, "GraphDataSourceSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.GraphDataSourceSchema; }
 });
-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)
+Object.defineProperty(exports, "ImportErrorSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.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)
+Object.defineProperty(exports, "ImportOptionsSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.ImportOptionsSchema; }
+});
+Object.defineProperty(exports, "ImportResultSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.ImportResultSchema; }
+});
+Object.defineProperty(exports, "InterchangeEdgeSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.InterchangeEdgeSchema; }
+});
+Object.defineProperty(exports, "InterchangeNodeSchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.InterchangeNodeSchema; }
+});
+Object.defineProperty(exports, "UnknownPropertyStrategySchema", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.UnknownPropertyStrategySchema; }
+});
+Object.defineProperty(exports, "exportGraph", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.exportGraph; }
+});
+Object.defineProperty(exports, "importGraph", {
+  enumerable: true,
+  get: function () { return chunkSB65GJNY_cjs.importGraph; }
 });
-
-// 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 ?? chunk7JGLPAFV_cjs.getNodeKinds(graph);
-  const edgeKindsToExport = options_.edgeKinds ?? chunk7JGLPAFV_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: chunk7JGLPAFV_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 nodeSchemas = buildNodeSchemaMap(graph);
-  const edgeSchemas = buildEdgeSchemaMap(graph);
-  const importedNodeIds = /* @__PURE__ */ new Set();
-  if (backend.capabilities.transactions) {
-    await backend.transaction(async (tx) => {
-      await processNodes(
-        tx,
-        graphId,
-        data.nodes,
-        nodeSchemas,
-        options,
-        result,
-        errors,
-        importedNodeIds
-      );
-      await processEdges(
-        tx,
-        graphId,
-        data.edges,
-        edgeSchemas,
-        nodeSchemas,
-        options,
-        result,
-        errors,
-        importedNodeIds
-      );
-    });
-  } else {
-    await processNodes(
-      backend,
-      graphId,
-      data.nodes,
-      nodeSchemas,
-      options,
-      result,
-      errors,
-      importedNodeIds
-    );
-    await processEdges(
-      backend,
-      graphId,
-      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 chunk7JGLPAFV_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 chunk7JGLPAFV_cjs.getEdgeKinds(graph)) {
-    const registration = graph.edges[kindName];
-    map.set(kindName, {
-      registration,
-      schema: registration.type.schema,
-      fromKinds: new Set(registration.from.map((node) => node.kind)),
-      toKinds: new Set(registration.to.map((node) => node.kind))
-    });
-  }
-  return map;
-}
-async function processNodes(backend, graphId, nodes, schemas, options, result, errors, importedNodeIds) {
-  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,
-        node,
-        schemas,
-        options
-      );
-      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++;
-          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 processNode(backend, graphId, node, schemas, options) {
-  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 existing = await backend.getNode(graphId, node.kind, node.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return { status: "skipped" };
-      }
-      case "error": {
-        return {
-          status: "error",
-          error: `Node already exists: ${node.kind}:${node.id}`
-        };
-      }
-      case "update": {
-        await backend.updateNode({
-          graphId,
-          kind: node.kind,
-          id: node.id,
-          props: propsResult.data,
-          incrementVersion: true,
-          ...node.validTo !== void 0 && { validTo: node.validTo }
-        });
-        return { status: "updated" };
-      }
-    }
-  }
-  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 }
-  });
-  return { status: "created" };
-}
-async function processEdges(backend, graphId, 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,
-        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, 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}` };
-  }
-  if (!schemaEntry.fromKinds.has(edge.from.kind)) {
-    return {
-      status: "error",
-      error: `Edge ${edge.kind} does not allow from kind: ${edge.from.kind}`
-    };
-  }
-  if (!schemaEntry.toKinds.has(edge.to.kind)) {
-    return {
-      status: "error",
-      error: `Edge ${edge.kind} does not allow to kind: ${edge.to.kind}`
-    };
-  }
-  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) {
-        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) {
-        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 existing = await backend.getEdge(graphId, edge.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return { status: "skipped" };
-      }
-      case "error": {
-        return { status: "error", error: `Edge already exists: ${edge.id}` };
-      }
-      case "update": {
-        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=index.cjs.map
 //# sourceMappingURL=index.cjs.map