db4ai 0.3.0 → 0.3.1

package/dist/chunk-EERD6CDF.js

@@ -0,0 +1,735 @@
+// cli/seed/index.ts
+var SeedError = class extends Error {
+  seedName;
+  type;
+  position;
+  constructor(message, context) {
+    super(message);
+    this.name = "SeedError";
+    if (context) {
+      this.seedName = context.seedName;
+      this.type = context.type;
+      this.position = context.position;
+    }
+  }
+};
+function Seed(input) {
+  if (!input.data && !input.source) {
+    throw new SeedError("Static seed must have data or source");
+  }
+  return {
+    kind: "static",
+    type: input.type,
+    data: input.data,
+    source: input.source,
+    headers: input.headers,
+    dataPath: input.dataPath,
+    nextPath: input.nextPath,
+    retries: input.retries,
+    transform: input.transform,
+    fieldMapping: input.fieldMapping,
+    readOnly: input.readOnly,
+    concurrency: input.concurrency
+  };
+}
+function Generate(input) {
+  const count = input.count ?? (input.ids ? void 0 : 1);
+  if (count === void 0 && !input.ids) {
+    throw new SeedError("Generated seed must have count or ids");
+  }
+  return {
+    kind: "generated",
+    type: input.type,
+    count,
+    ids: input.ids,
+    prompt: input.prompt,
+    constraints: input.constraints,
+    variations: input.variations,
+    cascade: input.cascade,
+    cascadeDepth: input.cascadeDepth,
+    cascadeReuse: input.cascadeReuse,
+    readOnly: input.readOnly,
+    concurrency: input.concurrency
+  };
+}
+function createSeedRunner(db, options) {
+  const {
+    seeds,
+    onProgress,
+    onCheckpoint,
+    onWarning,
+    onEntity,
+    beforeSeed,
+    afterSeed,
+    continueOnError = false,
+    timeout,
+    order,
+    validateSchema = false,
+    concurrency: globalConcurrency = 1,
+    dryRun = false,
+    skipExisting = false,
+    storage,
+    persist = false,
+    enableCache = false,
+    batchSize = 1
+  } = options;
+  const seedResultCache = /* @__PURE__ */ new Map();
+  const entityExistsCache = /* @__PURE__ */ new Map();
+  function getEntityCacheKey(type, id) {
+    return `${type}:${id}`;
+  }
+  async function checkEntityExists(type, id) {
+    const cacheKey = getEntityCacheKey(type, id);
+    if (enableCache && entityExistsCache.has(cacheKey)) {
+      return entityExistsCache.get(cacheKey);
+    }
+    const existing = await db.get(type, id);
+    const exists = existing !== null && existing !== void 0;
+    if (enableCache) {
+      entityExistsCache.set(cacheKey, exists);
+    }
+    return exists;
+  }
+  function markEntityCreated(type, id) {
+    if (enableCache) {
+      entityExistsCache.set(getEntityCacheKey(type, id), true);
+    }
+  }
+  function clearCaches() {
+    seedResultCache.clear();
+    entityExistsCache.clear();
+  }
+  async function processBatch(batch, seedName, total, phase, startTime) {
+    if (batch.length === 0) return 0;
+    let createdCount = 0;
+    await Promise.all(
+      batch.map(async (item) => {
+        await db.create(item.type, item.data);
+        markEntityCreated(item.type, item.data.id);
+        createdCount++;
+        if (onEntity) {
+          onEntity(item.type, item.data);
+        }
+        reportProgress(seedName, item.type, phase, item.position, total, startTime);
+      })
+    );
+    return createdCount;
+  }
+  function reportProgress(seedName, type, phase, position, total, startTime) {
+    if (onCheckpoint) {
+      onCheckpoint(position);
+    }
+    if (onProgress) {
+      const elapsedMs = Date.now() - startTime;
+      const rate = position / (elapsedMs / 1e3);
+      const eta = total > position ? Math.round(elapsedMs / position * (total - position)) : 0;
+      onProgress({
+        seedName,
+        type,
+        phase,
+        current: position,
+        total,
+        percentage: Math.round(position / total * 100),
+        rate,
+        eta
+      });
+    }
+  }
+  async function persistCheckpoint(seedName, position, total) {
+    if (persist && storage) {
+      await storage.set(
+        `seed:${seedName}:state`,
+        JSON.stringify({ position, total })
+      );
+    }
+  }
+  function extractReferences(typeDef) {
+    const refs = [];
+    if (!typeDef || typeof typeDef !== "object") return refs;
+    for (const [field, value] of Object.entries(typeDef)) {
+      if (typeof value === "string") {
+        const hardMatch = value.match(/^->([A-Z][a-zA-Z0-9]*)/);
+        if (hardMatch) {
+          refs.push({ type: hardMatch[1], fuzzy: false, field });
+        }
+        const fuzzyMatch = value.match(/^~>([A-Z][a-zA-Z0-9]*)/);
+        if (fuzzyMatch) {
+          refs.push({ type: fuzzyMatch[1], fuzzy: true, field });
+        }
+      }
+    }
+    return refs;
+  }
+  function extractReferenceTypes(typeDef) {
+    return extractReferences(typeDef).map((r) => r.type);
+  }
+  function isReadOnlyType(typeName) {
+    const typeDef = db.schema[typeName];
+    if (typeDef && typeof typeDef === "object" && "_readOnly" in typeDef) {
+      return !!typeDef._readOnly;
+    }
+    return false;
+  }
+  function getSeedType(config) {
+    return config.type;
+  }
+  function computeExecutionOrder() {
+    const seedNames = Object.keys(seeds);
+    const deps = /* @__PURE__ */ new Map();
+    const typeToSeed = /* @__PURE__ */ new Map();
+    for (const name of seedNames) {
+      deps.set(name, /* @__PURE__ */ new Set());
+      typeToSeed.set(getSeedType(seeds[name]), name);
+    }
+    for (const name of seedNames) {
+      const config = seeds[name];
+      const typeDef = db.schema[config.type];
+      const refs = extractReferenceTypes(typeDef);
+      for (const ref of refs) {
+        const depSeed = typeToSeed.get(ref);
+        if (depSeed && depSeed !== name) {
+          deps.get(name).add(depSeed);
+        }
+      }
+    }
+    const staticSeeds = seedNames.filter((n) => seeds[n].kind === "static");
+    const generatedSeeds = seedNames.filter((n) => seeds[n].kind === "generated");
+    for (const gen of generatedSeeds) {
+      for (const stat of staticSeeds) {
+        if (!deps.get(gen).has(stat)) {
+          deps.get(gen).add(stat);
+        }
+      }
+    }
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    function visit(name) {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        throw new SeedError(`Circular dependency detected involving seed "${name}"`);
+      }
+      visiting.add(name);
+      for (const dep of deps.get(name) || []) {
+        visit(dep);
+      }
+      visiting.delete(name);
+      visited.add(name);
+      result.push(name);
+    }
+    for (const name of seedNames) {
+      visit(name);
+    }
+    return result;
+  }
+  function applyFieldMapping(data, mapping) {
+    const result = {};
+    for (const [from, to] of Object.entries(mapping)) {
+      if (from in data) {
+        result[to] = data[from];
+      }
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (!(key in mapping)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  function extractDataPath(data, path) {
+    if (!path.startsWith("$.")) return Array.isArray(data) ? data : [];
+    const key = path.slice(2);
+    if (data && typeof data === "object" && key in data) {
+      const result = data[key];
+      return Array.isArray(result) ? result : [];
+    }
+    return [];
+  }
+  function extractNextPath(data, path) {
+    if (!path.startsWith("$.")) return null;
+    const key = path.slice(2);
+    if (data && typeof data === "object" && key in data) {
+      const result = data[key];
+      return typeof result === "string" ? result : null;
+    }
+    return null;
+  }
+  async function fetchWithRetry(url, headers, retries = 1) {
+    let lastError;
+    for (let i = 0; i < retries; i++) {
+      try {
+        const response = headers ? await fetch(url, { headers }) : await fetch(url);
+        if (response.ok) return response;
+        if (i === retries - 1) {
+          throw new SeedError(
+            `API request failed: ${response.status} ${response.statusText}`
+          );
+        }
+      } catch (error) {
+        lastError = error;
+        if (i === retries - 1) {
+          throw lastError;
+        }
+      }
+    }
+    throw lastError || new SeedError("Fetch failed");
+  }
+  function withTimeout(promise, ms) {
+    if (!ms) return promise;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new SeedError("Operation timeout exceeded"));
+      }, ms);
+      promise.then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  async function runWithConcurrency(items, fn, limit) {
+    const results = new Array(items.length);
+    let currentIndex = 0;
+    async function runNext() {
+      while (currentIndex < items.length) {
+        const index = currentIndex++;
+        results[index] = await fn(items[index], index);
+      }
+    }
+    const workers = Array.from(
+      { length: Math.min(limit, items.length) },
+      () => runNext()
+    );
+    await Promise.all(workers);
+    return results;
+  }
+  function selectVariation(variations, index, total) {
+    if (variations.length === 0) return {};
+    const totalWeight = variations.reduce((sum, v) => sum + (v.weight ?? 1), 0);
+    const normalizedWeights = variations.map((v) => (v.weight ?? 1) / totalWeight);
+    let cumulative = 0;
+    const position = index / total;
+    for (let i = 0; i < variations.length; i++) {
+      cumulative += normalizedWeights[i];
+      if (position < cumulative || i === variations.length - 1) {
+        const { weight: _2, ...rest2 } = variations[i];
+        return rest2;
+      }
+    }
+    const { weight: _, ...rest } = variations[0];
+    return rest;
+  }
+  async function cascadeGenerate(typeName, result, remainingDepth, reuse, visited) {
+    if (remainingDepth <= 0) return;
+    const typeDef = db.schema[typeName];
+    const refs = extractReferences(typeDef);
+    for (const ref of refs) {
+      const visitKey = `${typeName}:${ref.field}:${ref.type}`;
+      if (visited.has(visitKey)) continue;
+      visited.add(visitKey);
+      if (ref.fuzzy) {
+        await db.list(ref.type);
+        continue;
+      }
+      if (isReadOnlyType(ref.type)) continue;
+      const refId = result && typeof result === "object" ? result[ref.field] : void 0;
+      if (reuse && refId) {
+        const existing = await db.get(ref.type, refId);
+        if (existing) continue;
+      }
+      const generatedRef = await db.generate({
+        type: ref.type,
+        prompt: `${ref.type} for ${typeName}`
+      });
+      if (remainingDepth > 1) {
+        await cascadeGenerate(
+          ref.type,
+          generatedRef,
+          remainingDepth - 1,
+          reuse,
+          visited
+        );
+      }
+    }
+  }
+  function validateSchemaField(typeName, fieldName, strict) {
+    const typeDef = db.schema[typeName];
+    if (!typeDef || typeof typeDef !== "object") {
+      if (strict) {
+        throw new SeedError(`Type "${typeName}" not found in schema`);
+      }
+      return false;
+    }
+    if (fieldName === "weight") return true;
+    if (!(fieldName in typeDef)) {
+      if (strict) {
+        throw new SeedError(`Field "${fieldName}" not found in ${typeName}`);
+      }
+      if (onWarning) {
+        onWarning(`Field "${fieldName}" not found in ${typeName}`);
+      }
+      return false;
+    }
+    return true;
+  }
+  async function runSeed(seedName, config, runOpts) {
+    const startTime = Date.now();
+    const errors = [];
+    let created = 0;
+    let skipped = 0;
+    let partial = false;
+    let resumeToken;
+    let startPosition = 0;
+    if (runOpts?.resume) {
+      try {
+        const resumeData = JSON.parse(
+          Buffer.from(runOpts.resume, "base64").toString()
+        );
+        if (resumeData[seedName]?.position) {
+          startPosition = resumeData[seedName].position;
+        }
+      } catch {
+      }
+    }
+    if (validateSchema === true) {
+      if (!db.schema[config.type]) {
+        throw new SeedError(`Type "${config.type}" not found in schema`, {
+          seedName,
+          type: config.type
+        });
+      }
+    }
+    const phase = config.kind === "static" ? "static" : "generated";
+    if (config.kind === "static") {
+      let data;
+      if (config.data) {
+        data = [...config.data];
+        if (config.transform) {
+          data = await config.transform(data);
+        }
+      } else if (config.source) {
+        let allData = [];
+        let url = config.source;
+        while (url) {
+          const response = await fetchWithRetry(url, config.headers, config.retries || 1);
+          const json = await response.json();
+          if (config.transform) {
+            const transformed = await config.transform(json);
+            allData = allData.concat(transformed);
+            if (config.nextPath) {
+              url = extractNextPath(json, config.nextPath);
+            } else {
+              url = null;
+            }
+          } else if (config.dataPath) {
+            const pageData = extractDataPath(json, config.dataPath);
+            allData = allData.concat(pageData);
+            if (config.nextPath) {
+              url = extractNextPath(json, config.nextPath);
+            } else {
+              url = null;
+            }
+          } else if (Array.isArray(json)) {
+            allData = allData.concat(json);
+            url = null;
+          } else if (json.data && Array.isArray(json.data)) {
+            allData = allData.concat(json.data);
+            url = null;
+          } else {
+            allData.push(json);
+            url = null;
+          }
+        }
+        data = allData;
+      } else {
+        data = [];
+      }
+      if (config.fieldMapping) {
+        data = data.map(
+          (item) => applyFieldMapping(item, config.fieldMapping)
+        );
+      }
+      const total = data.length;
+      const concurrency = config.concurrency ?? globalConcurrency;
+      const processItem = async (item, index) => {
+        const position = index + 1;
+        const id = item.id;
+        if (id) {
+          const exists = await checkEntityExists(config.type, id);
+          if (exists) {
+            skipped++;
+            return;
+          }
+        }
+        const entityData = config.readOnly ? { ...item, _readOnly: true } : { ...item };
+        if (!entityData.id) {
+          const name = entityData.name;
+          entityData.id = name ? name.toLowerCase().replace(/\s+/g, "-") : `${config.type.toLowerCase()}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        }
+        if (!dryRun) {
+          await db.create(config.type, entityData);
+          markEntityCreated(config.type, entityData.id);
+          if (onEntity) {
+            onEntity(config.type, entityData);
+          }
+        }
+        created++;
+        reportProgress(seedName, config.type, phase, position, total, startTime);
+        await persistCheckpoint(seedName, position, total);
+      };
+      if (concurrency > 1) {
+        await runWithConcurrency(
+          data,
+          processItem,
+          concurrency
+        );
+      } else {
+        for (let i = 0; i < data.length; i++) {
+          await processItem(data[i], i);
+        }
+      }
+    } else {
+      const count = config.ids?.length ?? config.count ?? 1;
+      const total = count - startPosition;
+      const concurrency = config.concurrency ?? globalConcurrency;
+      if (validateSchema && config.constraints) {
+        const strict = validateSchema === true;
+        for (const field of Object.keys(config.constraints)) {
+          validateSchemaField(config.type, field, strict);
+        }
+      }
+      if (validateSchema && config.variations) {
+        const strict = validateSchema === true;
+        for (const variation of config.variations) {
+          for (const field of Object.keys(variation)) {
+            if (field !== "weight") {
+              validateSchemaField(config.type, field, strict);
+            }
+          }
+        }
+      }
+      let resolvedConstraints = config.constraints ? { ...config.constraints } : void 0;
+      if (resolvedConstraints) {
+        for (const [key, value] of Object.entries(resolvedConstraints)) {
+          if (value && typeof value === "object" && "ref" in value) {
+            const refType = value.ref;
+            await db.list(refType);
+          }
+        }
+      }
+      const generateEntity = async (index) => {
+        const actualIndex = startPosition + index;
+        const position = actualIndex + 1;
+        const id = config.ids?.[actualIndex];
+        if (skipExisting && id) {
+          const exists = await checkEntityExists(config.type, id);
+          if (exists) {
+            skipped++;
+            return;
+          }
+        }
+        let variationProps = {};
+        if (config.variations && config.variations.length > 0) {
+          variationProps = selectVariation(config.variations, actualIndex, count);
+        }
+        try {
+          const generateConfig = {
+            type: config.type,
+            prompt: config.prompt,
+            constraints: resolvedConstraints,
+            ...variationProps
+          };
+          if (id) {
+            generateConfig.id = id;
+          }
+          if (!dryRun) {
+            const result = await withTimeout(
+              db.generate(generateConfig),
+              timeout
+            );
+            if (config.cascade) {
+              await cascadeGenerate(
+                config.type,
+                result,
+                config.cascadeDepth ?? Infinity,
+                config.cascadeReuse ?? false,
+                /* @__PURE__ */ new Set()
+              );
+            }
+            if (onEntity) {
+              onEntity(config.type, result);
+            }
+          }
+          created++;
+          reportProgress(seedName, config.type, phase, position, count, startTime);
+          await persistCheckpoint(seedName, position, count);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorInfo = {
+            message: errorMessage,
+            position
+          };
+          if (error && typeof error === "object" && "code" in error && error.code === "INTERRUPTED") {
+            partial = true;
+            resumeToken = Buffer.from(
+              JSON.stringify({ [seedName]: { position } })
+            ).toString("base64");
+            errors.push(errorInfo);
+            return;
+          }
+          if (continueOnError) {
+            errors.push(errorInfo);
+          } else {
+            throw new SeedError(errorMessage, {
+              seedName,
+              type: config.type,
+              position
+            });
+          }
+        }
+      };
+      if (concurrency > 1) {
+        const indices = Array.from({ length: total }, (_, i) => i);
+        await runWithConcurrency(indices, generateEntity, concurrency);
+      } else {
+        for (let i = 0; i < total; i++) {
+          await generateEntity(i);
+        }
+      }
+    }
+    return {
+      success: errors.length === 0,
+      created,
+      skipped,
+      errors,
+      partial,
+      duration: Date.now() - startTime,
+      resumeToken
+    };
+  }
+  async function run(seedName, runOpts) {
+    const config = seeds[seedName];
+    if (!config) {
+      throw new SeedError(`Seed "${seedName}" not found`, { seedName });
+    }
+    if (!config.kind) {
+      throw new SeedError(`Invalid seed configuration for "${seedName}"`, { seedName });
+    }
+    let effectiveConfig = config;
+    if (beforeSeed) {
+      const hookResult = beforeSeed(seedName, config);
+      if (hookResult === null) {
+        return {
+          success: true,
+          created: 0,
+          skipped: 0,
+          errors: [],
+          partial: false,
+          duration: 0
+        };
+      }
+      if (hookResult) {
+        effectiveConfig = hookResult;
+      }
+    }
+    const result = await runSeed(seedName, effectiveConfig, runOpts);
+    if (afterSeed) {
+      afterSeed(seedName, result);
+    }
+    return result;
+  }
+  async function runAll() {
+    const startTime = Date.now();
+    const executionOrder = order ?? computeExecutionOrder();
+    if (dryRun) {
+      const wouldCreate = {};
+      for (const seedName of executionOrder) {
+        const config = seeds[seedName];
+        if (validateSchema === true) {
+          if (!db.schema[config.type]) {
+            throw new SeedError(`Type "${config.type}" not found in schema`, {
+              seedName,
+              type: config.type
+            });
+          }
+        }
+        if (config.kind === "static") {
+          wouldCreate[config.type] = config.data?.length ?? 0;
+        } else {
+          wouldCreate[config.type] = config.ids?.length ?? config.count ?? 1;
+        }
+      }
+      return {
+        success: true,
+        created: 0,
+        skipped: 0,
+        errors: [],
+        partial: false,
+        duration: Date.now() - startTime,
+        dryRun: true,
+        wouldCreate,
+        executionOrder
+      };
+    }
+    let totalCreated = 0;
+    let totalSkipped = 0;
+    const allErrors = [];
+    for (const seedName of executionOrder) {
+      const result = await run(seedName);
+      totalCreated += result.created;
+      totalSkipped += result.skipped;
+      allErrors.push(...result.errors);
+    }
+    return {
+      success: allErrors.length === 0,
+      created: totalCreated,
+      skipped: totalSkipped,
+      errors: allErrors,
+      partial: false,
+      duration: Date.now() - startTime
+    };
+  }
+  async function reset(seedName, resetOpts) {
+    const config = seeds[seedName];
+    if (!config) {
+      throw new SeedError(`Seed "${seedName}" not found`, { seedName });
+    }
+    await db.clear(config.type);
+    if (resetOpts?.cascade) {
+      const typeDef = db.schema[config.type];
+      const refs = extractReferenceTypes(typeDef);
+      for (const refType of refs) {
+        if (!isReadOnlyType(refType)) {
+          await db.clear(refType);
+        }
+      }
+    }
+    return run(seedName);
+  }
+  async function resetAll(resetOpts) {
+    for (const seedName of Object.keys(seeds)) {
+      const config = seeds[seedName];
+      if (resetOpts?.preserveReadOnly && config.readOnly) {
+        continue;
+      }
+      await db.clear(config.type);
+    }
+    return runAll();
+  }
+  return {
+    run,
+    runAll,
+    reset,
+    resetAll
+  };
+}
+
+export {
+  SeedError,
+  Seed,
+  Generate,
+  createSeedRunner
+};
+//# sourceMappingURL=chunk-EERD6CDF.js.map