realitydb 1.4.2 → 1.4.4

package/dist/index.js

@@ -10478,27 +10478,27 @@ var saasLifecycle = {
     {
       name: "trial",
       weight: 0.12,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "active",
       weight: 0.65,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "churned",
       weight: 0.1,
-      columnValues: {}
+      columnValues: { status: "inactive" }
     },
     {
       name: "past_due",
       weight: 0.08,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "paused",
       weight: 0.05,
-      columnValues: {}
+      columnValues: { status: "inactive" }
     }
   ],
   transitions: [
@@ -10510,7 +10510,7 @@ var saasLifecycle = {
         {
           table: "subscriptions",
           action: "create",
-          values: { status: "active", plan: "Professional" }
+          values: { status: "active" }
         },
         {
           table: "payments",
@@ -10613,20 +10613,6 @@ var saasLifecycle = {
     }
   ],
   correlations: [
-    {
-      description: "Enterprise plan users have 2x more payments (longer tenure)",
-      condition: {
-        table: "subscriptions",
-        column: "plan",
-        operator: "eq",
-        value: "Enterprise"
-      },
-      effect: {
-        table: "payments",
-        column: "amount_cents",
-        multiplier: 2
-      }
-    },
     {
       description: "Churned users always have a failed payment before cancel",
       condition: {
@@ -11731,53 +11717,13 @@ async function seedDatabase(config, options) {
       throw new Error(`Generation plan validation failed:
 ${validation.errors.join("\n")}`);
     }
-    let dataset;
     const lifecycleUsed = !!options?.lifecycle;
+    let dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
     if (options?.lifecycle && options?.template) {
       const lifecycle = resolveLifecycle(options.template);
       if (lifecycle) {
-        const random = createSeededRandom(plan.reproducibility.randomSeed);
-        const entityCount = effectiveConfig.seed.defaultRecords;
-        const simResult = simulateLifecycles(lifecycle, entityCount, random);
-        const correlatedResult = applyCorrelations(simResult, lifecycle.correlations, random);
-        const schemaColumnLookup = /* @__PURE__ */ new Map();
-        for (const table of schema.tables) {
-          schemaColumnLookup.set(table.name, new Set(table.columns.map((c) => c.name)));
-        }
-        const tables = /* @__PURE__ */ new Map();
-        let totalRows = 0;
-        for (const [tableName, rows] of correlatedResult.tables) {
-          const validColumns = schemaColumnLookup.get(tableName);
-          const filteredRows = validColumns ? rows.map((row) => {
-            const filtered = {};
-            for (const [col, val] of Object.entries(row)) {
-              if (validColumns.has(col)) {
-                filtered[col] = val;
-              } else {
-                console.warn(`[lifecycle] Skipping column '${col}' on table '${tableName}' \u2014 column does not exist`);
-              }
-            }
-            return filtered;
-          }) : rows;
-          tables.set(tableName, {
-            tableName,
-            columns: filteredRows.length > 0 ? Object.keys(filteredRows[0]) : [],
-            rows: filteredRows,
-            rowCount: filteredRows.length
-          });
-          totalRows += filteredRows.length;
-        }
-        dataset = {
-          tables,
-          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          seed: plan.reproducibility.randomSeed,
-          totalRows
-        };
-      } else {
-        dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
+        dataset = applyLifecycleOverlay(dataset, lifecycle, plan, schema);
       }
-    } else {
-      dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
     }
     let scenariosApplied;
     let scenarioReportData;
@@ -11819,6 +11765,66 @@ ${validation.errors.join("\n")}`);
     await closeConnection(pool);
   }
 }
+function applyLifecycleOverlay(dataset, lifecycle, plan, schema) {
+  const random = createSeededRandom(plan.reproducibility.randomSeed);
+  const rootTable = dataset.tables.get(lifecycle.rootTable);
+  const entityCount = rootTable?.rowCount ?? plan.tables[0]?.rowCount ?? 0;
+  const simResult = simulateLifecycles(lifecycle, entityCount, random);
+  const correlatedResult = applyCorrelations(simResult, lifecycle.correlations, random);
+  const schemaColumnLookup = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    schemaColumnLookup.set(table.name, new Set(table.columns.map((c) => c.name)));
+  }
+  const warnedColumns = /* @__PURE__ */ new Set();
+  if (rootTable) {
+    const lifecycleRootRows = correlatedResult.tables.get(lifecycle.rootTable);
+    if (lifecycleRootRows) {
+      const validColumns = schemaColumnLookup.get(lifecycle.rootTable);
+      const count = Math.min(rootTable.rows.length, lifecycleRootRows.length);
+      for (let i = 0; i < count; i++) {
+        for (const [col, val] of Object.entries(lifecycleRootRows[i])) {
+          if (col === "id")
+            continue;
+          if (validColumns && !validColumns.has(col)) {
+            const key = `${lifecycle.rootTable}.${col}`;
+            if (!warnedColumns.has(key)) {
+              console.warn(`[lifecycle] Skipping column '${col}' on table '${lifecycle.rootTable}' \u2014 does not exist in schema`);
+              warnedColumns.add(key);
+            }
+            continue;
+          }
+          rootTable.rows[i][col] = val;
+        }
+      }
+    }
+  }
+  for (const [tableName, lifecycleRows] of correlatedResult.tables) {
+    if (tableName === lifecycle.rootTable)
+      continue;
+    const existingTable = dataset.tables.get(tableName);
+    if (!existingTable || lifecycleRows.length === 0)
+      continue;
+    const validColumns = schemaColumnLookup.get(tableName);
+    const entityIdCol = `${lifecycle.entityName}_id`;
+    const count = Math.min(lifecycleRows.length, existingTable.rows.length);
+    for (let i = 0; i < count; i++) {
+      for (const [col, val] of Object.entries(lifecycleRows[i])) {
+        if (col === "id" || col === entityIdCol)
+          continue;
+        if (validColumns && !validColumns.has(col)) {
+          const key = `${tableName}.${col}`;
+          if (!warnedColumns.has(key)) {
+            console.warn(`[lifecycle] Skipping column '${col}' on table '${tableName}' \u2014 does not exist in schema`);
+            warnedColumns.add(key);
+          }
+          continue;
+        }
+        existingTable.rows[i][col] = val;
+      }
+    }
+  }
+  return dataset;
+}
 function computeTotalMonths(tc) {
   const start = new Date(tc.startDate);
   const end = new Date(tc.endDate);
@@ -12763,7 +12769,7 @@ var VERSION2 = "0.10.0";
 async function scanCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const result = await scanDatabase(config);
     const { schema } = result;
     const masked = maskConnectionString(config.database.connectionString);
@@ -12883,7 +12889,7 @@ var VERSION3 = "1.3.1";
 async function seedCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const records = options.records ? parseInt(options.records, 10) : void 0;
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const rawTemplateName = options.template ?? config.template;
@@ -13093,7 +13099,7 @@ async function resetCommand(options) {
     process.exit(0);
   }
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -13158,7 +13164,7 @@ var VERSION5 = "1.3.1";
 async function exportCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const format = options.format ?? config.export?.defaultFormat ?? "json";
     const outputDir = options.output ?? config.export?.outputDir ?? "./.realitydb";
     const records = options.records ? parseInt(options.records, 10) : void 0;
@@ -13518,7 +13524,7 @@ var import_node_path13 = require("path");
 var import_promises10 = require("fs/promises");
 async function packExportCommand(options) {
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const records = options.records ? parseInt(options.records, 10) : void 0;
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const rawTemplateName = options.template ?? config.template;
@@ -13620,7 +13626,7 @@ async function packImportCommand(filePath, options) {
       console.error("Usage: realitydb pack import <file> --confirm");
       process.exit(1);
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     const pack = await loadRealityPack(filePath);
     console.log("");
@@ -13689,7 +13695,7 @@ async function captureCommand(options) {
       console.error("Usage: realitydb capture --name <name>");
       process.exit(1);
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     const tables = options.tables ? options.tables.split(",").map((t) => t.trim()).filter((t) => t.length > 0) : void 0;
     if (!options.ci) {
@@ -13935,7 +13941,7 @@ async function loadCommand(filePath, options) {
       }
       return;
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -14254,7 +14260,7 @@ var VERSION12 = "1.3.1";
 async function analyzeCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const sampleSize = options.sampleSize ? parseInt(options.sampleSize, 10) : 1e3;
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
@@ -14348,7 +14354,7 @@ var VERSION13 = "1.3.1";
 async function maskCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const mode = options.mode ?? "gdpr";
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const dryRun = options.dryRun ?? false;
@@ -14557,7 +14563,7 @@ async function classroomListCommand(options) {
 async function classroomStartCommand(courseName, options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -15010,33 +15016,33 @@ async function simulateWebhooksCommand(options) {
 }
 
 // src/cli.ts
-var VERSION16 = "1.3.1";
+var VERSION16 = "1.4.4";
 function run(argv) {
   const program2 = new Command();
   program2.name("realitydb").description("RealityDB \u2014 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);
   program2.command("scan").description("Scan database schema").action(async () => {
     const opts = program2.opts();
-    await scanCommand({ ci: opts.ci });
+    await scanCommand({ ci: opts.ci, configPath: opts.config });
   });
   program2.command("analyze").description("Analyze database schema and suggest column strategies").option("--output <file>", "Generate a template JSON file from analysis").option("--sample-size <count>", "Number of rows to sample per table", "1000").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await analyzeCommand({ ...cmdOpts, ci: opts.ci });
+    await analyzeCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("seed").description("Seed database with generated data").option("--records <count>", "Number of records per table").option("--template <name|path>", "Template name or path to custom .json file").option("--seed <number>", "Random seed for reproducibility").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').option("--lifecycle", "Enable lifecycle simulation for causally-connected data").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await seedCommand({ ...cmdOpts, ci: opts.ci });
+    await seedCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("reset").description("Reset seeded data").option("--confirm", "Confirm destructive operation").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await resetCommand({ ...cmdOpts, ci: opts.ci });
+    await resetCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("export").description("Export generated data").option("--format <format>", "Output format (json|csv|sql)", "json").option("--output <dir>", "Output directory", "./.realitydb").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(async (cmdOpts) => {
     const opts = program2.opts();
-    await exportCommand({ ...cmdOpts, ci: opts.ci });
+    await exportCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("generate").description("Generate large-scale datasets for data science (no database required)").option("--records <count>", "Number of records to generate", "1000").option("--schema <file>", "Schema definition file (.sql or .json)").option("--format <format>", "Output format (json|csv|parquet)", "json").option("--output <dir>", "Output directory", "./.realitydb/generated").option("--seed <number>", "Random seed for reproducibility").option("--table <name>", "Generate only a specific table").option("--correlations", "Enable cross-column correlations from schema").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await generateCommand({ ...cmdOpts, ci: opts.ci });
+    await generateCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const templates = program2.command("templates").description("Template management");
   templates.command("list", { isDefault: true }).description("List available domain templates").action(templatesCommand);
@@ -15052,61 +15058,67 @@ function run(argv) {
   });
   program2.command("mask").description("Detect and mask PII in your database").option("--mode <mode>", "Compliance mode (hipaa|gdpr|strict)", "gdpr").option("--seed <number>", "Random seed for deterministic masking").option("--dry-run", "Preview PII detection without modifying data").option("--output <dir>", "Export masked data to files instead of writing to DB").option("--output-format <format>", "Output format (json|csv|sql)", "json").option("--audit-log <file>", "Write audit log to file").option("--confirm", "Confirm writing masked data back to database").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await maskCommand({ ...cmdOpts, ci: opts.ci });
+    await maskCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const classroom = program2.command("classroom").description("Education and classroom mode");
   classroom.command("list", { isDefault: true }).description("List available courses").action(async () => {
     const opts = program2.opts();
-    await classroomListCommand({ ci: opts.ci });
+    await classroomListCommand({ ci: opts.ci, configPath: opts.config });
   });
   classroom.command("start <course>").description("Load a course into your database").action(async (course) => {
     const opts = program2.opts();
-    await classroomStartCommand(course, { ci: opts.ci });
+    await classroomStartCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("status [course]").description("Show progress for all courses or a specific course").action(async (course) => {
     const opts = program2.opts();
-    await classroomStatusCommand(course, { ci: opts.ci });
+    await classroomStatusCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("complete <course> <exercise>").description("Mark an exercise as completed").action(async (course, exercise) => {
     const opts = program2.opts();
-    await classroomCompleteCommand(course, exercise, { ci: opts.ci });
+    await classroomCompleteCommand(course, exercise, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("reset <course>").description("Reset progress for a course").action(async (course) => {
     const opts = program2.opts();
-    await classroomResetCommand(course, { ci: opts.ci });
+    await classroomResetCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("create <name>").description("Scaffold a custom course JSON file").action(async (name) => {
     const opts = program2.opts();
-    await classroomCreateCommand(name, { ci: opts.ci });
+    await classroomCreateCommand(name, { ci: opts.ci, configPath: opts.config });
   });
   const simulate = program2.command("simulate").description("System behavior simulation");
   simulate.command("run", { isDefault: true }).description("Run a simulation with a profile").option("--profile <name>", "Simulation profile (saas-startup|ecommerce-peak|api-service)", "saas-startup").option("--duration <duration>", "Override profile duration (e.g., 1-hour, 1-day, 1-week)").option("--events <count>", "Number of events to generate", "1000").option("--seed <number>", "Random seed for reproducibility").option("--output <file>", "Output file path").option("--format <format>", "Output format (json|ndjson)", "json").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await simulateRunCommand({ ...cmdOpts, ci: opts.ci });
+    await simulateRunCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   simulate.command("profiles").description("List available simulation profiles").action(async () => {
     const opts = program2.opts();
-    await simulateProfilesCommand({ ci: opts.ci });
+    await simulateProfilesCommand({ ci: opts.ci, configPath: opts.config });
   });
   simulate.command("webhooks").description("Generate webhook events from a specific source").option("--source <source>", "Webhook source (stripe|github)", "stripe").option("--events <count>", "Number of events to generate", "100").option("--seed <number>", "Random seed for reproducibility").option("--output <file>", "Output file path").option("--format <format>", "Output format (json|ndjson)", "json").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await simulateWebhooksCommand({ ...cmdOpts, ci: opts.ci });
+    await simulateWebhooksCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("capture").description("Capture live database state into a Reality Pack").requiredOption("--name <name>", "Name for the captured pack").option("--description <desc>", "Pack description").option("--tables <tables>", "Comma-separated list of tables to capture").option("--output <dir>", "Output directory", ".").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await captureCommand({ ...cmdOpts, ci: opts.ci });
+    await captureCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("share <file>").description("Share a Reality Pack file").option("--gist", "Upload to GitHub Gist").option("--description <desc>", "Gist description").action(async (filePath, cmdOpts) => {
     const opts = program2.opts();
-    await shareCommand(filePath, { ...cmdOpts, ci: opts.ci });
+    await shareCommand(filePath, { ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("load <file>").description("Load a Reality Pack into the database (file path or URL)").option("--confirm", "Confirm import operation").option("--show-ddl", "Show schema DDL without importing").action(async (filePath, cmdOpts) => {
     const opts = program2.opts();
-    await loadCommand(filePath, { ...cmdOpts, ci: opts.ci });
+    await loadCommand(filePath, { ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const pack = program2.command("pack").description("Reality Pack operations");
-  pack.command("export").description("Export environment as Reality Pack").option("--name <name>", "Pack name").option("--description <desc>", "Pack description").option("--output <dir>", "Output directory", ".").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(packExportCommand);
-  pack.command("import <file>").description("Import Reality Pack into database").option("--confirm", "Confirm import operation").action(packImportCommand);
+  pack.command("export").description("Export environment as Reality Pack").option("--name <name>", "Pack name").option("--description <desc>", "Pack description").option("--output <dir>", "Output directory", ".").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(async (cmdOpts) => {
+    const opts = program2.opts();
+    await packExportCommand({ ...cmdOpts, configPath: opts.config });
+  });
+  pack.command("import <file>").description("Import Reality Pack into database").option("--confirm", "Confirm import operation").action(async (filePath, cmdOpts) => {
+    const opts = program2.opts();
+    await packImportCommand(filePath, { ...cmdOpts, configPath: opts.config });
+  });
   const packs = program2.command("packs").description("Browse available Reality Packs");
   packs.command("list", { isDefault: true }).description("List available demo packs").action(() => {
     const opts = program2.opts();

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "realitydb",
-  "version": "1.4.2",
+
+  "version": "1.4.4",
   "description": "Developer Reality Platform - realistic database environments from your schema",
   "license": "MIT",
   "keywords": [
@@ -59,3 +60,4 @@
     "pg": "^8.20.0"
   }
 }
+