@objectstack/runtime 8.0.1 → 9.0.0

package/dist/index.js

@@ -143,601 +143,10 @@ var seed_loader_exports = {};
 __export(seed_loader_exports, {
   SeedLoaderService: () => SeedLoaderService
 });
-import { SeedLoaderConfigSchema } from "@objectstack/spec/data";
-import { resolveSeedRecord } from "@objectstack/formula";
-var DEFAULT_EXTERNAL_ID_FIELD, _SeedLoaderService, SeedLoaderService;
+import { SeedLoaderService } from "@objectstack/objectql";
 var init_seed_loader = __esm({
   "src/seed-loader.ts"() {
     "use strict";
-    DEFAULT_EXTERNAL_ID_FIELD = "name";
-    _SeedLoaderService = class _SeedLoaderService {
-      constructor(engine, metadata, logger) {
-        this.engine = engine;
-        this.metadata = metadata;
-        this.logger = logger;
-      }
-      // ==========================================================================
-      // Public API
-      // ==========================================================================
-      async load(request) {
-        const startTime = Date.now();
-        const config = request.config;
-        const allErrors = [];
-        const allResults = [];
-        const datasets = this.filterByEnv(request.seeds, config.env);
-        if (datasets.length === 0) {
-          return this.buildEmptyResult(config, Date.now() - startTime);
-        }
-        const objectNames = datasets.map((d) => d.object);
-        const graph = await this.buildDependencyGraph(objectNames);
-        this.logger.info("[SeedLoader] Dependency graph built", {
-          objects: objectNames.length,
-          insertOrder: graph.insertOrder,
-          circularDeps: graph.circularDependencies.length
-        });
-        const orderedDatasets = this.orderDatasets(datasets, graph.insertOrder);
-        const refMap = this.buildReferenceMap(graph);
-        const insertedRecords = /* @__PURE__ */ new Map();
-        const deferredUpdates = [];
-        for (const dataset of orderedDatasets) {
-          const result = await this.loadDataset(
-            dataset,
-            config,
-            refMap,
-            insertedRecords,
-            deferredUpdates,
-            allErrors
-          );
-          allResults.push(result);
-          if (config.haltOnError && result.errored > 0) {
-            this.logger.warn("[SeedLoader] Halting on first error", { object: dataset.object });
-            break;
-          }
-        }
-        if (config.multiPass && deferredUpdates.length > 0 && !config.dryRun) {
-          this.logger.info("[SeedLoader] Pass 2: resolving deferred references", {
-            count: deferredUpdates.length
-          });
-          await this.resolveDeferredUpdates(deferredUpdates, insertedRecords, allResults, allErrors, config.organizationId);
-        }
-        const durationMs = Date.now() - startTime;
-        return this.buildResult(config, graph, allResults, allErrors, durationMs);
-      }
-      async buildDependencyGraph(objectNames) {
-        const nodes = [];
-        const objectSet = new Set(objectNames);
-        for (const objectName of objectNames) {
-          const objDef = await this.metadata.getObject(objectName);
-          const dependsOn = [];
-          const references = [];
-          if (objDef && objDef.fields) {
-            const fields = objDef.fields;
-            for (const [fieldName, fieldDef] of Object.entries(fields)) {
-              if ((fieldDef.type === "lookup" || fieldDef.type === "master_detail") && fieldDef.reference) {
-                const targetObject = fieldDef.reference;
-                if (objectSet.has(targetObject) && !dependsOn.includes(targetObject)) {
-                  dependsOn.push(targetObject);
-                }
-                references.push({
-                  field: fieldName,
-                  targetObject,
-                  targetField: DEFAULT_EXTERNAL_ID_FIELD,
-                  fieldType: fieldDef.type
-                });
-              }
-            }
-          }
-          nodes.push({ object: objectName, dependsOn, references });
-        }
-        const { insertOrder, circularDependencies } = this.topologicalSort(nodes);
-        return { nodes, insertOrder, circularDependencies };
-      }
-      async validate(datasets, config) {
-        const parsedConfig = SeedLoaderConfigSchema.parse({ ...config, dryRun: true });
-        return this.load({ seeds: datasets, config: parsedConfig });
-      }
-      // ==========================================================================
-      // Internal: Seed Loading
-      // ==========================================================================
-      async loadDataset(dataset, config, refMap, insertedRecords, deferredUpdates, allErrors) {
-        const objectName = dataset.object;
-        const mode = dataset.mode || config.defaultMode;
-        const externalId = dataset.externalId || "name";
-        let inserted = 0;
-        let updated = 0;
-        let skipped = 0;
-        let errored = 0;
-        let referencesResolved = 0;
-        let referencesDeferred = 0;
-        const errors = [];
-        if (!insertedRecords.has(objectName)) {
-          insertedRecords.set(objectName, /* @__PURE__ */ new Map());
-        }
-        let existingRecords;
-        if ((mode === "upsert" || mode === "update" || mode === "ignore") && !config.dryRun) {
-          existingRecords = await this.loadExistingRecords(
-            objectName,
-            externalId,
-            config.organizationId
-          );
-        }
-        const objectRefs = refMap.get(objectName) || [];
-        const seedNow = /* @__PURE__ */ new Date();
-        const seedIdentity = config.identity;
-        const baseEvalCtx = {
-          now: seedNow,
-          user: seedIdentity?.user,
-          // Fall back to the per-tenant organizationId so `os.org.id` resolves
-          // during per-org replay even without an explicit identity.org.
-          org: seedIdentity?.org ?? (config.organizationId ? { id: config.organizationId } : void 0),
-          env: config.env
-        };
-        for (let i = 0; i < dataset.records.length; i++) {
-          const seedResult = resolveSeedRecord(
-            dataset.records[i],
-            baseEvalCtx
-          );
-          if (!seedResult.ok) {
-            errored++;
-            const error = {
-              sourceObject: objectName,
-              field: "(expression)",
-              targetObject: objectName,
-              targetField: "(expression)",
-              attemptedValue: dataset.records[i],
-              recordIndex: i,
-              message: `Cannot resolve dynamic seed values for ${objectName} record #${i}: ${seedResult.error.message}. Records using cel\`os.user.id\` / cel\`os.org.id\` require a seed identity \u2014 ensure a system/admin user exists before seeding (see SeedLoaderConfig.identity).`
-            };
-            errors.push(error);
-            allErrors.push(error);
-            this.logger.warn(`[SeedLoader] ${error.message}`);
-            continue;
-          }
-          const record = { ...seedResult.value };
-          if (config.organizationId && record["organization_id"] == null) {
-            record["organization_id"] = config.organizationId;
-          }
-          for (const ref of objectRefs) {
-            const fieldValue = record[ref.field];
-            if (fieldValue === void 0 || fieldValue === null) continue;
-            if (typeof fieldValue === "object") {
-              const wrapped = fieldValue.externalId;
-              const hint = wrapped !== void 0 ? ` Pass the natural key directly: ${ref.field}: ${JSON.stringify(wrapped)}.` : ` Pass the target's ${ref.targetField} value as a plain string.`;
-              const error = {
-                sourceObject: objectName,
-                field: ref.field,
-                targetObject: ref.targetObject,
-                targetField: ref.targetField,
-                attemptedValue: fieldValue,
-                recordIndex: i,
-                message: `Invalid reference for ${objectName}.${ref.field}: expected a ${ref.targetObject}.${ref.targetField} natural-key string but got an object.${hint}`
-              };
-              errors.push(error);
-              allErrors.push(error);
-              this.logger.warn(`[SeedLoader] ${error.message}`, { recordIndex: i });
-              record[ref.field] = null;
-              continue;
-            }
-            if (typeof fieldValue !== "string" || this.looksLikeInternalId(fieldValue)) continue;
-            const targetMap = insertedRecords.get(ref.targetObject);
-            const resolvedId = targetMap?.get(String(fieldValue));
-            if (resolvedId) {
-              record[ref.field] = resolvedId;
-              referencesResolved++;
-            } else if (!config.dryRun) {
-              const dbId = await this.resolveFromDatabase(ref.targetObject, ref.targetField, fieldValue, config.organizationId);
-              if (dbId) {
-                record[ref.field] = dbId;
-                referencesResolved++;
-              } else if (config.multiPass) {
-                record[ref.field] = null;
-                deferredUpdates.push({
-                  objectName,
-                  recordExternalId: String(record[externalId] ?? ""),
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i
-                });
-                referencesDeferred++;
-              } else {
-                const error = {
-                  sourceObject: objectName,
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i,
-                  message: `Cannot resolve reference: ${objectName}.${ref.field} = '${fieldValue}' \u2192 ${ref.targetObject}.${ref.targetField} not found`
-                };
-                errors.push(error);
-                allErrors.push(error);
-              }
-            } else {
-              const targetMap2 = insertedRecords.get(ref.targetObject);
-              if (!targetMap2?.has(String(fieldValue))) {
-                const error = {
-                  sourceObject: objectName,
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i,
-                  message: `[dry-run] Reference may not resolve: ${objectName}.${ref.field} = '${fieldValue}' \u2192 ${ref.targetObject}.${ref.targetField}`
-                };
-                errors.push(error);
-                allErrors.push(error);
-              }
-            }
-          }
-          if (!config.dryRun) {
-            try {
-              const result = await this.writeRecord(
-                objectName,
-                record,
-                mode,
-                externalId,
-                existingRecords
-              );
-              if (result.action === "inserted") inserted++;
-              else if (result.action === "updated") updated++;
-              else if (result.action === "skipped") skipped++;
-              const externalIdValue = String(record[externalId] ?? "");
-              const internalId = result.id;
-              if (externalIdValue && internalId) {
-                insertedRecords.get(objectName).set(externalIdValue, String(internalId));
-              }
-            } catch (err) {
-              errored++;
-              const error = {
-                sourceObject: objectName,
-                field: "(write)",
-                targetObject: objectName,
-                targetField: externalId,
-                attemptedValue: record[externalId] ?? null,
-                recordIndex: i,
-                message: `Failed to write ${objectName} record #${i} (${externalId}=${String(record[externalId] ?? "")}): ${err.message}`
-              };
-              errors.push(error);
-              allErrors.push(error);
-              this.logger.warn(`[SeedLoader] ${error.message}`, { recordIndex: i });
-            }
-          } else {
-            const externalIdValue = String(record[externalId] ?? "");
-            if (externalIdValue) {
-              insertedRecords.get(objectName).set(externalIdValue, `dry-run-id-${i}`);
-            }
-            inserted++;
-          }
-        }
-        return {
-          object: objectName,
-          mode,
-          inserted,
-          updated,
-          skipped,
-          errored,
-          total: dataset.records.length,
-          referencesResolved,
-          referencesDeferred,
-          errors
-        };
-      }
-      // ==========================================================================
-      // Internal: Reference Resolution
-      // ==========================================================================
-      async resolveFromDatabase(targetObject, targetField, value, organizationId) {
-        try {
-          const where = { [targetField]: value };
-          if (organizationId) where.organization_id = organizationId;
-          const records = await this.engine.find(targetObject, {
-            where,
-            fields: ["id"],
-            limit: 1,
-            context: { isSystem: true }
-          });
-          if (records && records.length > 0) {
-            return String(records[0].id || records[0]._id);
-          }
-        } catch {
-        }
-        return null;
-      }
-      async resolveDeferredUpdates(deferredUpdates, insertedRecords, allResults, allErrors, organizationId) {
-        for (const deferred of deferredUpdates) {
-          const targetMap = insertedRecords.get(deferred.targetObject);
-          let resolvedId = targetMap?.get(String(deferred.attemptedValue));
-          if (!resolvedId) {
-            resolvedId = await this.resolveFromDatabase(
-              deferred.targetObject,
-              deferred.targetField,
-              deferred.attemptedValue,
-              organizationId
-            ) ?? void 0;
-          }
-          if (resolvedId) {
-            const objectRecordMap = insertedRecords.get(deferred.objectName);
-            const recordId = objectRecordMap?.get(deferred.recordExternalId);
-            if (recordId) {
-              try {
-                await this.engine.update(deferred.objectName, {
-                  id: recordId,
-                  [deferred.field]: resolvedId
-                }, { context: { isSystem: true } });
-                const resultEntry = allResults.find((r) => r.object === deferred.objectName);
-                if (resultEntry) {
-                  resultEntry.referencesResolved++;
-                  resultEntry.referencesDeferred--;
-                }
-              } catch (err) {
-                this.logger.warn("[SeedLoader] Failed to resolve deferred reference", {
-                  object: deferred.objectName,
-                  field: deferred.field,
-                  error: err.message
-                });
-              }
-            }
-          } else {
-            const error = {
-              sourceObject: deferred.objectName,
-              field: deferred.field,
-              targetObject: deferred.targetObject,
-              targetField: deferred.targetField,
-              attemptedValue: deferred.attemptedValue,
-              recordIndex: deferred.recordIndex,
-              message: `Deferred reference unresolved after pass 2: ${deferred.objectName}.${deferred.field} = '${deferred.attemptedValue}' \u2192 ${deferred.targetObject}.${deferred.targetField} not found`
-            };
-            const resultEntry = allResults.find((r) => r.object === deferred.objectName);
-            if (resultEntry) {
-              resultEntry.errors.push(error);
-            }
-            allErrors.push(error);
-          }
-        }
-      }
-      async writeRecord(objectName, record, mode, externalId, existingRecords) {
-        const externalIdValue = record[externalId];
-        const existing = existingRecords?.get(String(externalIdValue ?? ""));
-        const opts = _SeedLoaderService.SEED_OPTIONS;
-        switch (mode) {
-          case "insert": {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          case "update": {
-            if (!existing) {
-              return { action: "skipped" };
-            }
-            const id = this.extractId(existing);
-            await this.engine.update(objectName, { ...record, id }, opts);
-            return { action: "updated", id };
-          }
-          case "upsert": {
-            if (existing) {
-              const id = this.extractId(existing);
-              await this.engine.update(objectName, { ...record, id }, opts);
-              return { action: "updated", id };
-            } else {
-              const result = await this.engine.insert(objectName, record, opts);
-              return { action: "inserted", id: this.extractId(result) };
-            }
-          }
-          case "ignore": {
-            if (existing) {
-              return { action: "skipped", id: this.extractId(existing) };
-            }
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          case "replace": {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          default: {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-        }
-      }
-      // ==========================================================================
-      // Internal: Dependency Graph
-      // ==========================================================================
-      /**
-       * Kahn's algorithm for topological sort with cycle detection.
-       */
-      topologicalSort(nodes) {
-        const inDegree = /* @__PURE__ */ new Map();
-        const adjacency = /* @__PURE__ */ new Map();
-        const objectSet = new Set(nodes.map((n) => n.object));
-        for (const node of nodes) {
-          inDegree.set(node.object, 0);
-          adjacency.set(node.object, []);
-        }
-        for (const node of nodes) {
-          for (const dep of node.dependsOn) {
-            if (objectSet.has(dep) && dep !== node.object) {
-              adjacency.get(dep).push(node.object);
-              inDegree.set(node.object, (inDegree.get(node.object) || 0) + 1);
-            }
-          }
-        }
-        const queue = [];
-        for (const [obj, degree] of inDegree) {
-          if (degree === 0) queue.push(obj);
-        }
-        const insertOrder = [];
-        while (queue.length > 0) {
-          const current = queue.shift();
-          insertOrder.push(current);
-          for (const neighbor of adjacency.get(current) || []) {
-            const newDegree = (inDegree.get(neighbor) || 0) - 1;
-            inDegree.set(neighbor, newDegree);
-            if (newDegree === 0) {
-              queue.push(neighbor);
-            }
-          }
-        }
-        const circularDependencies = [];
-        const remaining = nodes.filter((n) => !insertOrder.includes(n.object));
-        if (remaining.length > 0) {
-          const cycles = this.findCycles(remaining);
-          circularDependencies.push(...cycles);
-          for (const node of remaining) {
-            if (!insertOrder.includes(node.object)) {
-              insertOrder.push(node.object);
-            }
-          }
-        }
-        return { insertOrder, circularDependencies };
-      }
-      findCycles(nodes) {
-        const cycles = [];
-        const nodeMap = new Map(nodes.map((n) => [n.object, n]));
-        const visited = /* @__PURE__ */ new Set();
-        const inStack = /* @__PURE__ */ new Set();
-        const dfs = (current, path) => {
-          if (inStack.has(current)) {
-            const cycleStart = path.indexOf(current);
-            if (cycleStart !== -1) {
-              cycles.push([...path.slice(cycleStart), current]);
-            }
-            return;
-          }
-          if (visited.has(current)) return;
-          visited.add(current);
-          inStack.add(current);
-          path.push(current);
-          const node = nodeMap.get(current);
-          if (node) {
-            for (const dep of node.dependsOn) {
-              if (nodeMap.has(dep)) {
-                dfs(dep, [...path]);
-              }
-            }
-          }
-          inStack.delete(current);
-        };
-        for (const node of nodes) {
-          if (!visited.has(node.object)) {
-            dfs(node.object, []);
-          }
-        }
-        return cycles;
-      }
-      // ==========================================================================
-      // Internal: Helpers
-      // ==========================================================================
-      filterByEnv(datasets, env) {
-        if (!env) return datasets;
-        return datasets.filter((d) => d.env.includes(env));
-      }
-      orderDatasets(datasets, insertOrder) {
-        const orderMap = new Map(insertOrder.map((name, i) => [name, i]));
-        return [...datasets].sort((a, b) => {
-          const orderA = orderMap.get(a.object) ?? Number.MAX_SAFE_INTEGER;
-          const orderB = orderMap.get(b.object) ?? Number.MAX_SAFE_INTEGER;
-          return orderA - orderB;
-        });
-      }
-      buildReferenceMap(graph) {
-        const map = /* @__PURE__ */ new Map();
-        for (const node of graph.nodes) {
-          if (node.references.length > 0) {
-            map.set(node.object, node.references);
-          }
-        }
-        return map;
-      }
-      async loadExistingRecords(objectName, externalId, organizationId) {
-        const map = /* @__PURE__ */ new Map();
-        try {
-          const findArgs = {
-            fields: ["id", externalId],
-            context: { isSystem: true }
-          };
-          if (organizationId) findArgs.where = { organization_id: organizationId };
-          const records = await this.engine.find(objectName, findArgs);
-          for (const record of records || []) {
-            const key = String(record[externalId] ?? "");
-            if (key) {
-              map.set(key, record);
-            }
-          }
-        } catch {
-        }
-        return map;
-      }
-      looksLikeInternalId(value) {
-        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
-          return true;
-        }
-        if (/^[0-9a-f]{24}$/i.test(value)) {
-          return true;
-        }
-        return false;
-      }
-      extractId(record) {
-        if (!record) return void 0;
-        return String(record.id || record._id || "");
-      }
-      buildEmptyResult(config, durationMs) {
-        return {
-          success: true,
-          dryRun: config.dryRun,
-          dependencyGraph: { nodes: [], insertOrder: [], circularDependencies: [] },
-          results: [],
-          errors: [],
-          summary: {
-            objectsProcessed: 0,
-            totalRecords: 0,
-            totalInserted: 0,
-            totalUpdated: 0,
-            totalSkipped: 0,
-            totalErrored: 0,
-            totalReferencesResolved: 0,
-            totalReferencesDeferred: 0,
-            circularDependencyCount: 0,
-            durationMs
-          }
-        };
-      }
-      buildResult(config, graph, results, errors, durationMs) {
-        const summary = {
-          objectsProcessed: results.length,
-          totalRecords: results.reduce((sum, r) => sum + r.total, 0),
-          totalInserted: results.reduce((sum, r) => sum + r.inserted, 0),
-          totalUpdated: results.reduce((sum, r) => sum + r.updated, 0),
-          totalSkipped: results.reduce((sum, r) => sum + r.skipped, 0),
-          totalErrored: results.reduce((sum, r) => sum + r.errored, 0),
-          totalReferencesResolved: results.reduce((sum, r) => sum + r.referencesResolved, 0),
-          totalReferencesDeferred: results.reduce((sum, r) => sum + r.referencesDeferred, 0),
-          circularDependencyCount: graph.circularDependencies.length,
-          durationMs
-        };
-        const hasErrors = errors.length > 0 || summary.totalErrored > 0;
-        return {
-          success: !hasErrors,
-          dryRun: config.dryRun,
-          dependencyGraph: graph,
-          results,
-          errors,
-          summary
-        };
-      }
-    };
-    // ==========================================================================
-    // Internal: Write Operations
-    // ==========================================================================
-    /**
-     * Seed writes always run as a privileged system context. This bypasses
-     * RBAC checks (so seeds can target system tables like `sys_*`) and
-     * disables the SecurityPlugin's auto-injection of `organization_id` /
-     * `owner_id` — seeds either declare those fields explicitly per
-     * record, or are intentionally cross-tenant / global.
-     */
-    _SeedLoaderService.SEED_OPTIONS = { context: { isSystem: true } };
-    SeedLoaderService = _SeedLoaderService;
   }
 });
 
@@ -3976,17 +3385,19 @@ var _HttpDispatcher = class _HttpDispatcher {
               ...organizationId ? { organizationId } : {},
               ...body?.actor ? { actor: body.actor } : {}
             });
-            try {
-              const seedNames = (result?.published ?? []).filter((p) => p?.type === "seed").map((p) => p.name);
-              if (seedNames.length > 0) {
-                result.seedApplied = await this.applyPublishedSeeds(
-                  seedNames,
-                  organizationId,
-                  _context
-                );
+            if (result?.seedApplied === void 0) {
+              try {
+                const seedNames = (result?.published ?? []).filter((p) => p?.type === "seed").map((p) => p.name);
+                if (seedNames.length > 0) {
+                  result.seedApplied = await this.applyPublishedSeeds(
+                    seedNames,
+                    organizationId,
+                    _context
+                  );
+                }
+              } catch (e) {
+                result.seedApplied = { success: false, error: e?.message ?? "seed apply failed" };
               }
-            } catch (e) {
-              result.seedApplied = { success: false, error: e?.message ?? "seed apply failed" };
             }
             return { handled: true, response: this.success(result) };
           } catch (e) {