@doviui/dev-db 0.1.0 → 0.2.0

package/README.md

@@ -81,19 +81,27 @@ export default {
 
 #### Using the CLI directly
 
-Run the CLI to generate JSON files:
+Run the CLI to generate JSON files from a single schema file or a directory:
 
 ```bash
-# Generate from a directory of schemas
-bunx @doviui/dev-db generate ./schemas -o ./mock-data
+# Generate from a single schema file
+bunx @doviui/dev-db schema.ts
 
-# Generate from a single file
-bunx @doviui/dev-db generate ./schemas/user.schema.ts -o ./data
+# Generate from a directory of schema files
+bunx @doviui/dev-db ./schemas
+
+# Specify output directory
+bunx @doviui/dev-db schema.ts -o ./data
 
 # Use a seed for reproducible data
-bunx @doviui/dev-db generate ./schemas --seed 42
+bunx @doviui/dev-db ./schemas --seed 42
+
+# Combine options
+bunx @doviui/dev-db ./schemas -o ./mock-data -s 42
 ```
 
+**Directory Support:** When a directory is provided, all `.ts` and `.js` files are loaded and their schemas are merged. This allows you to organize related tables across multiple files for better maintainability.
+
 #### Adding to package.json scripts
 
 Add generation to your project's scripts:
@@ -101,8 +109,8 @@ Add generation to your project's scripts:
 ```json
 {
   "scripts": {
-    "generate:data": "bunx @doviui/dev-db generate ./schemas -o ./mock-data",
-    "generate:data:seed": "bunx @doviui/dev-db generate ./schemas -o ./mock-data --seed 42"
+    "generate:data": "bunx @doviui/dev-db ./schemas -o ./mock-data",
+    "generate:data:seed": "bunx @doviui/dev-db ./schemas -o ./mock-data -s 42"
   }
 }
 ```
@@ -221,7 +229,11 @@ Chain modifiers to configure field behavior and constraints:
 
 ### Multi-Table Schemas
 
-Define multiple related tables in a single file for better organization:
+You can organize schemas in two ways:
+
+**Option 1: Single file with multiple tables**
+
+Define multiple related tables in a single file:
 
 ```typescript
 // schemas/social.schema.ts
@@ -233,14 +245,60 @@ export default {
     id: t.bigserial().primaryKey(),
     username: t.varchar(50).unique()
   },
-  
+
   Post: {
     $count: 500,
     id: t.bigserial().primaryKey(),
     user_id: t.foreignKey('User', 'id'),
     title: t.varchar(200)
   },
-  
+
+  Comment: {
+    $count: 2000,
+    id: t.uuid().primaryKey(),
+    post_id: t.foreignKey('Post', 'id'),
+    user_id: t.foreignKey('User', 'id'),
+    content: t.text()
+  }
+}
+```
+
+**Option 2: Multiple files in a directory**
+
+Organize each table in its own file for better maintainability:
+
+```typescript
+// schemas/users.ts
+import { t } from '@doviui/dev-db'
+
+export default {
+  User: {
+    $count: 100,
+    id: t.bigserial().primaryKey(),
+    username: t.varchar(50).unique()
+  }
+}
+```
+
+```typescript
+// schemas/posts.ts
+import { t } from '@doviui/dev-db'
+
+export default {
+  Post: {
+    $count: 500,
+    id: t.bigserial().primaryKey(),
+    user_id: t.foreignKey('User', 'id'),
+    title: t.varchar(200)
+  }
+}
+```
+
+```typescript
+// schemas/comments.ts
+import { t } from '@doviui/dev-db'
+
+export default {
   Comment: {
     $count: 2000,
     id: t.uuid().primaryKey(),
@@ -251,6 +309,8 @@ export default {
 }
 ```
 
+Then generate with: `bunx @doviui/dev-db ./schemas`
+
 ### Schema Validation
 
 dev-db validates schemas before generation to catch errors early:
@@ -267,11 +327,9 @@ export default {
 
 **Output:**
 ```
-🔍 Validating schemas...
-
-❌ Schema validation failed:
+Schema validation failed:
 
-  • Post.user_id: Foreign key references non-existent table 'User'
+  Post.user_id: Foreign key references non-existent table 'User'
 ```
 
 ### Custom Data Generators
@@ -304,18 +362,66 @@ t.jsonb().generate((faker) => ({
 ## Command Line Interface
 
 ```bash
-bunx @doviui/dev-db generate <schemas> [options]
+dev-db <path> [options]
 
 Arguments:
-  schemas                Path to schema file or directory
+  <path>                 Path to schema file or directory containing schema files
 
 Options:
-  -o, --output <dir>     Output directory (default: "./mock-data")
-  -s, --seed <number>    Random seed for reproducibility
-  -h, --help             Display help
-  -v, --version          Display version
+  -o, --output <dir>     Output directory for generated JSON files (default: ./mock-data)
+  -s, --seed <number>    Random seed for reproducible data generation
+  -h, --help             Show help message
 ```
 
+**Examples:**
+
+```bash
+# Single file
+bunx @doviui/dev-db schema.ts
+
+# Directory of schemas
+bunx @doviui/dev-db ./schemas
+
+# Custom output directory
+bunx @doviui/dev-db ./schemas -o ./data
+
+# Reproducible generation with seed
+bunx @doviui/dev-db schema.ts -s 42
+
+# All options combined
+bunx @doviui/dev-db ./schemas --output ./database --seed 12345
+```
+
+**Schema File Format:**
+
+Schema files must export a default object or named `schema` export:
+
+```typescript
+import { t } from '@doviui/dev-db';
+
+export default {
+  User: {
+    $count: 100,
+    id: t.bigserial().primaryKey(),
+    email: t.varchar(255).unique().notNull().generate('internet.email'),
+    name: t.varchar(100).notNull()
+  }
+};
+```
+
+**Directory Support:**
+
+When a directory is provided, all `.ts` and `.js` files are loaded and their schemas are merged. This allows you to organize schemas across multiple files:
+
+```
+schemas/
+  ├── users.ts      // exports { User: { ... } }
+  ├── posts.ts      // exports { Post: { ... } }
+  └── comments.ts   // exports { Comment: { ... } }
+```
+
+Running `bunx @doviui/dev-db ./schemas` will merge all three schemas and generate data for all tables.
+
 ### Programmatic API
 
 For more control, create a custom generation script:
@@ -330,8 +436,11 @@ const validator = new SchemaValidator()
 const errors = validator.validate(schema)
 
 if (errors.length > 0) {
-  console.error('❌ Schema validation failed:')
-  errors.forEach(err => console.error(`  • ${err.message}`))
+  console.error('Schema validation failed:')
+  errors.forEach(err => {
+    const location = err.field ? `${err.table}.${err.field}` : err.table
+    console.error(`  ${location}: ${err.message}`)
+  })
   process.exit(1)
 }
 
@@ -342,7 +451,7 @@ const generator = new MockDataGenerator(schema, {
 })
 
 await generator.generate()
-console.log('✓ Mock data generated successfully!')
+console.log('Mock data generated successfully!')
 ```
 
 Add to package.json:

package/cli.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI for @doviui/dev-db - Generate mock JSON databases from TypeScript schemas
+ */
+
+import { MockDataGenerator } from './src/generator';
+import { SchemaValidator } from './src/validator';
+import type { Schema } from './src/types';
+import { readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+
+const HELP_TEXT = `
+@doviui/dev-db - Generate realistic mock JSON databases
+
+USAGE:
+  dev-db <path> [options]
+
+ARGUMENTS:
+  <path>               Path to schema file or directory containing schema files
+
+OPTIONS:
+  -o, --output <dir>     Output directory for generated JSON files (default: ./mock-data)
+  -s, --seed <number>    Random seed for reproducible data generation
+  -h, --help             Show this help message
+
+EXAMPLES:
+  dev-db schema.ts
+  dev-db ./schemas
+  dev-db schema.ts -o ./data -s 42
+  dev-db ./schemas --output ./database --seed 12345
+
+SCHEMA FILE FORMAT:
+  Schema files must export a default object or named 'schema' export:
+
+  import { t } from '@doviui/dev-db';
+
+  export default {
+    User: {
+      $count: 100,
+      id: t.bigserial().primaryKey(),
+      email: t.varchar(255).unique().notNull().generate('internet.email'),
+      name: t.varchar(100).notNull()
+    }
+  };
+
+DIRECTORY SUPPORT:
+  When a directory is provided, all .ts and .js files are loaded and their
+  schemas are merged. This allows you to organize schemas across multiple files.
+`;
+
+interface CLIOptions {
+  schemaPath?: string;
+  outputDir: string;
+  seed?: number;
+  help: boolean;
+}
+
+function parseArgs(args: string[]): CLIOptions {
+  const options: CLIOptions = {
+    outputDir: './mock-data',
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+    } else if (arg === '-o' || arg === '--output') {
+      const nextArg = args[++i];
+      if (nextArg) options.outputDir = nextArg;
+    } else if (arg === '-s' || arg === '--seed') {
+      const nextArg = args[++i];
+      if (nextArg !== undefined) options.seed = parseInt(nextArg, 10);
+    } else if (!arg.startsWith('-')) {
+      options.schemaPath = arg;
+    }
+  }
+
+  return options;
+}
+
+async function loadSchemaFromFile(filePath: string): Promise<Schema> {
+  try {
+    // Resolve path relative to current working directory
+    const resolvedPath = filePath.startsWith('.') || filePath.startsWith('/')
+      ? filePath
+      : `./${filePath}`;
+
+    const module = await import(resolvedPath);
+    const schema = module.default || module.schema;
+
+    if (!schema) {
+      throw new Error(
+        'Schema file must export a default object or named "schema" export'
+      );
+    }
+
+    return schema;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to load schema file: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+async function loadSchemaFromDirectory(dirPath: string): Promise<Schema> {
+  try {
+    const resolvedDir = dirPath.startsWith('.') || dirPath.startsWith('/')
+      ? dirPath
+      : `./${dirPath}`;
+
+    const files = readdirSync(resolvedDir);
+    const schemaFiles = files.filter(file => {
+      const ext = extname(file);
+      return ext === '.ts' || ext === '.js';
+    });
+
+    if (schemaFiles.length === 0) {
+      throw new Error(`No schema files (.ts or .js) found in directory: ${dirPath}`);
+    }
+
+    const mergedSchema: Schema = {};
+
+    for (const file of schemaFiles) {
+      const filePath = join(resolvedDir, file);
+      const schema = await loadSchemaFromFile(filePath);
+
+      // Merge schemas
+      Object.assign(mergedSchema, schema);
+    }
+
+    return mergedSchema;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to load schemas from directory: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+async function loadSchema(path: string): Promise<Schema> {
+  const resolvedPath = path.startsWith('.') || path.startsWith('/')
+    ? path
+    : `./${path}`;
+
+  const stats = statSync(resolvedPath);
+
+  if (stats.isDirectory()) {
+    return loadSchemaFromDirectory(path);
+  } else if (stats.isFile()) {
+    return loadSchemaFromFile(path);
+  } else {
+    throw new Error(`Path is neither a file nor a directory: ${path}`);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help || !options.schemaPath) {
+    console.log(HELP_TEXT);
+    process.exit(options.help ? 0 : 1);
+  }
+
+  try {
+    const schema = await loadSchema(options.schemaPath);
+
+    const validator = new SchemaValidator();
+    const errors = validator.validate(schema);
+
+    if (errors.length > 0) {
+      console.error('Schema validation failed:\n');
+      errors.forEach((error) => {
+        const location = error.field ? `${error.table}.${error.field}` : error.table;
+        console.error(`  ${location}: ${error.message}`);
+      });
+      process.exit(1);
+    }
+
+    const generator = new MockDataGenerator(schema, {
+      outputDir: options.outputDir,
+      seed: options.seed,
+    });
+
+    await generator.generate();
+
+    console.log(`Generated mock data in: ${options.outputDir}`);
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@doviui/dev-db",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "TypeScript-first mock database generator for rapid application development",
   "main": "index.ts",
   "module": "index.ts",
   "types": "index.ts",
   "type": "module",
+  "bin": {
+    "dev-db": "./cli.ts"
+  },
   "exports": {
     ".": {
       "import": "./index.ts",
@@ -13,6 +16,7 @@
     }
   },
   "files": [
+    "cli.ts",
     "index.ts",
     "src/**/*.ts",
     "README.md",

package/src/generator.ts

@@ -337,14 +337,10 @@ export class MockDataGenerator {
   private async writeDataToFiles(): Promise<void> {
     const outputDir = this.options.outputDir ?? './mock-data';
 
-    // Create output directory if it doesn't exist
-    await Bun.write(`${outputDir}/.gitkeep`, '');
-
-    // Write each table to a JSON file
+    // Write each table to a JSON file (directory is created automatically)
     for (const [tableName, data] of Object.entries(this.generatedData)) {
       const filePath = `${outputDir}/${tableName}.json`;
       await Bun.write(filePath, JSON.stringify(data, null, 2));
-      console.log(` Generated ${data.length} records for ${tableName} -> ${filePath}`);
     }
   }