realitydb 1.7.0 → 1.8.0

package/dist/index.js

@@ -22938,11 +22938,13 @@ function generateEnum(ctx, values, weights) {
   if (!weights || weights.length === 0) {
     result = ctx.seed.pick(values);
   } else {
+    const sum = weights.reduce((a, b) => a + b, 0);
+    const normalized = sum > 0 && Math.abs(sum - 1) > 1e-3 ? weights.map((w) => w / sum) : weights;
     const roll = ctx.seed.next();
     let cumulative = 0;
     result = values[values.length - 1];
     for (let i = 0; i < values.length; i++) {
-      cumulative += weights[i];
+      cumulative += normalized[i];
       if (roll < cumulative) {
         result = values[i];
         break;
@@ -23185,6 +23187,10 @@ function generateDataset(plan) {
           }
         }
       }
+      if (tablePlan.temporalConstraints && tablePlan.temporalConstraints.length > 0) {
+        applyTemporalFixup(row, tablePlan.temporalConstraints, seed);
+      }
+      applyLifecycleRules(row, tablePlan.columns);
       rows.push(row);
     }
     const generatedTable = {
@@ -23206,6 +23212,49 @@ function generateDataset(plan) {
     totalRows
   };
 }
+function applyTemporalFixup(row, constraints, seed) {
+  for (const constraint of constraints) {
+    if (constraint.mode !== "dependent" || !constraint.afterColumn)
+      continue;
+    const baseValue = row[constraint.afterColumn];
+    const depValue = row[constraint.columnName];
+    if (baseValue == null || depValue == null)
+      continue;
+    if (typeof baseValue !== "string" && !(baseValue instanceof Date))
+      continue;
+    const baseDate = new Date(baseValue);
+    if (isNaN(baseDate.getTime()))
+      continue;
+    const depDate = new Date(depValue);
+    const withinDays = constraint.withinDays ?? 90;
+    if (isNaN(depDate.getTime()) || depDate <= baseDate) {
+      const offsetMs = (1 + Math.floor(seed.next() * withinDays)) * 864e5;
+      const newDate = new Date(baseDate.getTime() + offsetMs);
+      row[constraint.columnName] = newDate.toISOString();
+    }
+  }
+}
+function applyLifecycleRules(row, columns) {
+  for (const colPlan of columns) {
+    if (colPlan.strategy.kind !== "enum")
+      continue;
+    const lifecycleRules = colPlan.strategy.options?.["lifecycleRules"];
+    if (!lifecycleRules || !Array.isArray(lifecycleRules))
+      continue;
+    const currentValue = row[colPlan.columnName];
+    if (typeof currentValue !== "string")
+      continue;
+    for (const rule of lifecycleRules) {
+      if (rule.value === currentValue && Array.isArray(rule.nullFields)) {
+        for (const field of rule.nullFields) {
+          if (field in row) {
+            row[field] = null;
+          }
+        }
+      }
+    }
+  }
+}
 
 // ../../packages/generators/dist/exporters/json.js
 var import_promises = require("fs/promises");
@@ -29554,6 +29603,19 @@ function validateTemplateJSON(json) {
       if (c.options !== void 0 && (typeof c.options !== "object" || Array.isArray(c.options))) {
         errors.push(`Table "${tableName}".columns."${colName}": "options" must be an object`);
       }
+      if (c.foreignKey !== void 0) {
+        if (typeof c.foreignKey !== "object" || Array.isArray(c.foreignKey) || c.foreignKey === null) {
+          errors.push(`Table "${tableName}".columns."${colName}": "foreignKey" must be an object`);
+        } else {
+          const fk = c.foreignKey;
+          if (typeof fk.table !== "string" || !fk.table) {
+            errors.push(`Table "${tableName}".columns."${colName}": "foreignKey.table" must be a non-empty string`);
+          }
+          if (typeof fk.column !== "string" || !fk.column) {
+            errors.push(`Table "${tableName}".columns."${colName}": "foreignKey.column" must be a non-empty string`);
+          }
+        }
+      }
     }
   }
   return { valid: errors.length === 0, errors };
@@ -29594,15 +29656,31 @@ function convertToDomainTemplate(json) {
     const columnOverrides = [];
     for (const [colName, colJson] of Object.entries(tableJson.columns)) {
       const col = colJson;
-      columnOverrides.push({
-        columnName: colName,
-        matchPattern: col.match,
-        strategy: {
-          kind: col.strategy,
-          options: col.options
-        },
-        description: col.description
-      });
+      if (col.foreignKey) {
+        columnOverrides.push({
+          columnName: colName,
+          matchPattern: col.match,
+          strategy: {
+            kind: "foreign_key",
+            options: {
+              ...col.options,
+              referencedTable: col.foreignKey.table,
+              referencedColumn: col.foreignKey.column
+            }
+          },
+          description: col.description
+        });
+      } else {
+        columnOverrides.push({
+          columnName: colName,
+          matchPattern: col.match,
+          strategy: {
+            kind: col.strategy,
+            options: col.options
+          },
+          description: col.description
+        });
+      }
     }
     tableConfigs.set(tableName, {
       tableName,
@@ -29616,7 +29694,9 @@ function convertToDomainTemplate(json) {
     version: json.version,
     description: json.description,
     targetTables,
-    tableConfigs
+    tableConfigs,
+    simulation: json.simulation,
+    generationConfig: json.generationConfig
   };
 }
 
@@ -29973,7 +30053,7 @@ var fintechLifecycle = {
 
 // ../../packages/core/dist/planning/buildPlan.js
 function buildGenerationPlan(schema, config, timelineConfig) {
-  const defaultRowCount = config.seed.defaultRecords;
+  let defaultRowCount = config.seed.defaultRecords;
   const batchSize = config.seed.batchSize;
   const environment = config.seed.environment ?? "dev";
   const randomSeed = config.seed.randomSeed ?? 42;
@@ -30090,18 +30170,41 @@ function buildGenerationPlan(schema, config, timelineConfig) {
           selectionMode: "uniform"
         };
         columnPlan.foreignKeyRef = ref;
+      } else if (strategy.kind === "foreign_key" && strategy.options?.["referencedTable"] && strategy.options?.["referencedColumn"]) {
+        columnPlan.strategy = { kind: "foreign_key" };
+        columnPlan.foreignKeyRef = {
+          referencedTable: strategy.options["referencedTable"],
+          referencedColumn: strategy.options["referencedColumn"],
+          selectionMode: "uniform"
+        };
       }
       return columnPlan;
     });
+    const templateTemporalConstraints = [];
+    for (const colPlan of columns) {
+      const opts = colPlan.strategy.options;
+      if (opts?.["dependsOn"] && typeof opts["dependsOn"] === "string") {
+        templateTemporalConstraints.push({
+          columnName: colPlan.columnName,
+          afterColumn: opts["dependsOn"],
+          mode: "dependent",
+          withinDays: 90
+        });
+      }
+    }
     const rowCount = tableConfig?.rowCountMultiplier ? Math.round(defaultRowCount * tableConfig.rowCountMultiplier) : defaultRowCount;
     const enabled = template ? tableConfig !== null : true;
-    return {
+    const tablePlan = {
       tableName: table.name,
       rowCount,
       dependencies: uniqueDeps,
       columns,
       enabled
     };
+    if (templateTemporalConstraints.length > 0) {
+      tablePlan.temporalConstraints = templateTemporalConstraints;
+    }
+    return tablePlan;
   });
   if (template) {
     const enabledSet = new Set(tables.filter((t) => t.enabled).map((t) => t.tableName));
@@ -30452,6 +30555,17 @@ async function batchInsertDataset(client, dataset, tableOrder, batchSize, dialec
   const start = performance.now();
   const results = [];
   let totalRows = 0;
+  const targetTables = tableOrder.filter((name) => dataset.tables.has(name));
+  for (let i = targetTables.length - 1; i >= 0; i--) {
+    const tableName = quoteIdent(dialect, targetTables[i]);
+    if (dialect === "mysql") {
+      await client.query("SET FOREIGN_KEY_CHECKS = 0");
+      await client.query(`TRUNCATE TABLE ${tableName}`);
+      await client.query("SET FOREIGN_KEY_CHECKS = 1");
+    } else {
+      await client.query(`TRUNCATE TABLE ${tableName} CASCADE`);
+    }
+  }
   for (const tableName of tableOrder) {
     const table = dataset.tables.get(tableName);
     if (!table)
@@ -31136,6 +31250,18 @@ async function seedDatabase(config, options) {
   if (options?.template !== void 0) {
     effectiveConfig.template = options.template;
   }
+  if (options?.records === void 0 && effectiveConfig.template) {
+    const isFilePath = effectiveConfig.template.includes("/") || effectiveConfig.template.includes("\\") || effectiveConfig.template.endsWith(".json");
+    if (isFilePath) {
+      try {
+        const tmpl = loadTemplateFromJSON(effectiveConfig.template);
+        if (tmpl.generationConfig?.seed?.defaultRecords) {
+          effectiveConfig.seed.defaultRecords = tmpl.generationConfig.seed.defaultRecords;
+        }
+      } catch {
+      }
+    }
+  }
   const timelineConfig = options?.timeline ? parseTimelineString(options.timeline) : void 0;
   if (timelineConfig) {
     timelineConfig.growthModel.finalCount = effectiveConfig.seed.defaultRecords;
@@ -35154,7 +35280,7 @@ async function simulateWebhooksCommand(options) {
 }
 
 // src/cli.ts
-var VERSION16 = "1.7.0";
+var VERSION16 = "1.8.0";
 function run(argv) {
   const program2 = new Command();
   program2.name("realitydb").description("RealityDB \xC3\u0192\xC6\u2019\xC3\u2020\xE2\u20AC\u2122\xC3\u0192\xE2\u20AC\u0161\xC3\u201A\xC2\xA2\xC3\u0192\xC6\u2019\xC3\u201A\xC2\xA2\xC3\u0192\xC2\xA2\xC3\xA2\xE2\u20AC\u0161\xC2\xAC\xC3\u2026\xC2\xA1\xC3\u0192\xE2\u20AC\u0161\xC3\u201A\xC2\xAC\xC3\u0192\xC6\u2019\xC3\u201A\xC2\xA2\xC3\u0192\xC2\xA2\xC3\xA2\xE2\u201A\xAC\xC5\xA1\xC3\u201A\xC2\xAC\xC3\u0192\xE2\u20AC\u0161\xC3\u201A\xC2\x9D Developer Reality Platform").version(VERSION16).option("--config <path>", "Path to config file").option("--ci", "CI mode: JSON output, no prompts, proper exit codes", false).option("--verbose", "Enable verbose output", false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "realitydb",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Developer Reality Platform - realistic database environments from your schema",
   "license": "MIT",
   "keywords": [