@doviui/dev-db 0.1.0

package/src/field-builder.ts

@@ -0,0 +1,188 @@
+import type { Faker } from '@faker-js/faker';
+import type { FieldConfig, FieldBuilderLike } from './types';
+
+export type Generator = string | ((faker: Faker) => any);
+
+/**
+ * Builder class for defining database field configurations with a fluent API.
+ *
+ * @example
+ * ```typescript
+ * const field = new FieldBuilder('varchar', 255)
+ *   .unique()
+ *   .notNull()
+ *   .generate('internet.email');
+ * ```
+ */
+export class FieldBuilder implements FieldBuilderLike {
+  protected config: FieldConfig;
+
+  /**
+   * Creates a new FieldBuilder instance.
+   *
+   * @param type - The SQL-like type of the field
+   * @param length - Optional length for string types
+   * @param precision - Optional precision for numeric types
+   * @param scale - Optional scale for numeric types
+   */
+  constructor(type: string, length?: number, precision?: number, scale?: number) {
+    this.config = {
+      type,
+      length,
+      precision,
+      scale,
+      nullable: true,
+    };
+  }
+
+  /**
+   * Marks this field as a primary key.
+   * Automatically sets notNull to true and nullable to false.
+   *
+   * @returns The builder instance for chaining
+   */
+  primaryKey(): this {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    this.config.nullable = false;
+    return this;
+  }
+
+  /**
+   * Enforces uniqueness constraint on this field.
+   * All generated values will be unique.
+   *
+   * @returns The builder instance for chaining
+   */
+  unique(): this {
+    this.config.unique = true;
+    return this;
+  }
+
+  /**
+   * Marks this field as NOT NULL.
+   * Generated values will never be null.
+   *
+   * @returns The builder instance for chaining
+   */
+  notNull(): this {
+    this.config.notNull = true;
+    this.config.nullable = false;
+    return this;
+  }
+
+  /**
+   * Marks this field as nullable.
+   * Generated values may occasionally be null (10% chance by default).
+   *
+   * @returns The builder instance for chaining
+   */
+  nullable(): this {
+    this.config.nullable = true;
+    this.config.notNull = false;
+    return this;
+  }
+
+  /**
+   * Sets a default value for this field.
+   *
+   * @param value - The default value. Use 'now' for current timestamp.
+   * @returns The builder instance for chaining
+   *
+   * @example
+   * ```typescript
+   * t.boolean().default(true)
+   * t.timestamptz().default('now')
+   * ```
+   */
+  default(value: any): this {
+    this.config.default = value;
+    return this;
+  }
+
+  /**
+   * Sets the minimum value for numeric fields.
+   *
+   * @param value - Minimum allowed value
+   * @returns The builder instance for chaining
+   */
+  min(value: number): this {
+    this.config.min = value;
+    return this;
+  }
+
+  /**
+   * Sets the maximum value for numeric fields.
+   *
+   * @param value - Maximum allowed value
+   * @returns The builder instance for chaining
+   */
+  max(value: number): this {
+    this.config.max = value;
+    return this;
+  }
+
+  /**
+   * Restricts field values to a specific set of allowed values.
+   *
+   * @param values - Array of allowed values
+   * @returns The builder instance for chaining
+   *
+   * @example
+   * ```typescript
+   * t.varchar(20).enum(['draft', 'published', 'archived'])
+   * ```
+   */
+  enum(values: any[]): this {
+    this.config.enum = values;
+    return this;
+  }
+
+  /**
+   * Sets a custom generator for field values.
+   *
+   * @param generator - Either a Faker.js method path or a custom function
+   * @returns The builder instance for chaining
+   *
+   * @example
+   * ```typescript
+   * // Using Faker.js method
+   * t.varchar(100).generate('internet.email')
+   *
+   * // Using custom function
+   * t.varchar(20).generate((faker) =>
+   *   faker.helpers.arrayElement(['red', 'blue', 'green'])
+   * )
+   * ```
+   */
+  generate(generator: Generator): this {
+    this.config.generator = generator;
+    return this;
+  }
+
+  /**
+   * Converts the builder to a plain FieldConfig object.
+   *
+   * @returns The field configuration
+   */
+  toConfig(): FieldConfig {
+    return this.config;
+  }
+}
+
+/**
+ * Builder class for foreign key fields.
+ * Extends FieldBuilder with foreign key-specific configuration.
+ */
+export class ForeignKeyBuilder extends FieldBuilder {
+  /**
+   * Creates a new foreign key field builder.
+   *
+   * @param table - The referenced table name
+   * @param column - The referenced column name
+   */
+  constructor(table: string, column: string) {
+    super('foreignKey');
+    this.config.foreignKey = { table, column };
+  }
+}

package/src/generator.ts

@@ -0,0 +1,360 @@
+import { faker } from '@faker-js/faker';
+import type { Schema, FieldConfig, TableConfig } from './types';
+
+/**
+ * Options for configuring the mock data generator.
+ */
+export interface GeneratorOptions {
+  /** Directory where generated JSON files will be saved (default: './mock-data') */
+  outputDir?: string;
+
+  /** Random seed for reproducible data generation */
+  seed?: number;
+}
+
+/**
+ * Generated data indexed by table name.
+ */
+interface GeneratedData {
+  [tableName: string]: any[];
+}
+
+/**
+ * Generates realistic mock data from schema definitions.
+ *
+ * Features:
+ * - Topological sorting to handle foreign key dependencies
+ * - Unique value generation with retry logic
+ * - Custom generators via Faker.js or custom functions
+ * - Enum support
+ * - Min/max constraints for numeric types
+ * - Automatic foreign key resolution
+ *
+ * @example
+ * ```typescript
+ * const generator = new MockDataGenerator(schema, {
+ *   outputDir: './mock-data',
+ *   seed: 42 // Optional: for reproducible data
+ * });
+ *
+ * const data = await generator.generate();
+ * console.log(`Generated ${data.User.length} users`);
+ * ```
+ */
+export class MockDataGenerator {
+  private schema: Schema;
+  private options: GeneratorOptions;
+  private generatedData: GeneratedData = {};
+
+  /**
+   * Creates a new mock data generator.
+   *
+   * @param schema - The schema definition
+   * @param options - Generator options
+   */
+  constructor(schema: Schema, options: GeneratorOptions = {}) {
+    this.schema = schema;
+    this.options = {
+      outputDir: options.outputDir || './mock-data',
+      seed: options.seed,
+    };
+
+    if (this.options.seed !== undefined) {
+      faker.seed(this.options.seed);
+    }
+  }
+
+  /**
+   * Generates mock data for all tables in the schema.
+   *
+   * Tables are processed in dependency order (based on foreign keys).
+   * Generated data is written to JSON files in the output directory.
+   *
+   * @returns Promise resolving to the generated data indexed by table name
+   *
+   * @example
+   * ```typescript
+   * const data = await generator.generate();
+   * // Files created: ./mock-data/User.json, ./mock-data/Post.json, etc.
+   * ```
+   */
+  async generate(): Promise<GeneratedData> {
+    // Topologically sort tables based on foreign key dependencies
+    const sortedTables = this.topologicalSort();
+
+    // Generate data for each table in order
+    for (const tableName of sortedTables) {
+      const tableConfig = this.schema[tableName];
+      if (!tableConfig) continue;
+
+      const count = tableConfig.$count || 10;
+
+      this.generatedData[tableName] = this.generateTableData(tableName, tableConfig, count);
+    }
+
+    // Write data to files
+    await this.writeDataToFiles();
+
+    return this.generatedData;
+  }
+
+  private topologicalSort(): string[] {
+    const tables = Object.keys(this.schema);
+    const visited = new Set<string>();
+    const result: string[] = [];
+
+    const visit = (tableName: string) => {
+      if (visited.has(tableName)) return;
+      visited.add(tableName);
+
+      const tableConfig = this.schema[tableName];
+      if (!tableConfig) return;
+
+      const fields = Object.entries(tableConfig).filter(([key]) => key !== '$count');
+
+      // Visit dependencies first
+      for (const [_, field] of fields) {
+        const fieldConfig = this.toFieldConfig(field);
+        if (fieldConfig?.foreignKey) {
+          const refTable = fieldConfig.foreignKey.table;
+          if (refTable !== tableName) { // Avoid self-references
+            visit(refTable);
+          }
+        }
+      }
+
+      result.push(tableName);
+    };
+
+    for (const tableName of tables) {
+      visit(tableName);
+    }
+
+    return result;
+  }
+
+  private generateTableData(tableName: string, tableConfig: TableConfig, count: number): any[] {
+    const records: any[] = [];
+    const uniqueValues = new Map<string, Set<any>>();
+
+    for (let i = 0; i < count; i++) {
+      const record: any = {};
+      const fields = Object.entries(tableConfig).filter(([key]) => key !== '$count');
+
+      for (const [fieldName, field] of fields) {
+        const fieldConfig = this.toFieldConfig(field);
+        if (fieldConfig) {
+          record[fieldName] = this.generateFieldValue(
+            fieldName,
+            fieldConfig,
+            i,
+            uniqueValues,
+            tableName
+          );
+        }
+      }
+
+      records.push(record);
+    }
+
+    return records;
+  }
+
+  private toFieldConfig(field: any): FieldConfig | null {
+    if (!field) return null;
+    if (typeof field === 'object' && 'toConfig' in field) {
+      return field.toConfig();
+    }
+    if (typeof field === 'object' && 'type' in field) {
+      return field;
+    }
+    return null;
+  }
+
+  private generateFieldValue(
+    fieldName: string,
+    fieldConfig: FieldConfig,
+    index: number,
+    uniqueValues: Map<string, Set<any>>,
+    tableName: string
+  ): any {
+    // Handle default values
+    if (fieldConfig.default !== undefined) {
+      if (fieldConfig.default === 'now') {
+        return new Date().toISOString();
+      }
+      return fieldConfig.default;
+    }
+
+    // Handle foreign keys
+    if (fieldConfig.foreignKey) {
+      const refTable = fieldConfig.foreignKey.table;
+      const refColumn = fieldConfig.foreignKey.column;
+      const refData = this.generatedData[refTable];
+
+      if (!refData || refData.length === 0) {
+        if (fieldConfig.nullable) return null;
+        throw new Error(`Cannot generate foreign key for ${tableName}.${fieldName}: no data in ${refTable}`);
+      }
+
+      const randomRecord = refData[Math.floor(Math.random() * refData.length)];
+      return randomRecord[refColumn];
+    }
+
+    // Handle serial/bigserial auto-increment
+    if (fieldConfig.type === 'serial' || fieldConfig.type === 'bigserial') {
+      return index + 1;
+    }
+
+    // Handle nullable fields (but not if they have enum, min/max constraints, or custom generators)
+    if (
+      fieldConfig.nullable &&
+      !fieldConfig.notNull &&
+      !fieldConfig.enum &&
+      !fieldConfig.generator &&
+      fieldConfig.min === undefined &&
+      fieldConfig.max === undefined &&
+      Math.random() < 0.1
+    ) {
+      return null;
+    }
+
+    // Generate value with uniqueness check
+    let value: any;
+    let attempts = 0;
+    const maxAttempts = 1000;
+
+    do {
+      value = this.generateValueByType(fieldConfig);
+      attempts++;
+
+      if (attempts >= maxAttempts) {
+        throw new Error(
+          `Could not generate unique value for ${tableName}.${fieldName} after ${maxAttempts} attempts`
+        );
+      }
+    } while (
+      fieldConfig.unique &&
+      uniqueValues.get(fieldName)?.has(JSON.stringify(value))
+    );
+
+    // Track unique values
+    if (fieldConfig.unique) {
+      if (!uniqueValues.has(fieldName)) {
+        uniqueValues.set(fieldName, new Set());
+      }
+      uniqueValues.get(fieldName)!.add(JSON.stringify(value));
+    }
+
+    return value;
+  }
+
+  private generateValueByType(fieldConfig: FieldConfig): any {
+    // Use custom generator if provided
+    if (fieldConfig.generator) {
+      if (typeof fieldConfig.generator === 'string') {
+        return this.callFakerMethod(fieldConfig.generator);
+      } else {
+        return fieldConfig.generator(faker);
+      }
+    }
+
+    // Use enum if provided
+    if (fieldConfig.enum && fieldConfig.enum.length > 0) {
+      return fieldConfig.enum[Math.floor(Math.random() * fieldConfig.enum.length)];
+    }
+
+    // Generate based on type
+    switch (fieldConfig.type) {
+      case 'uuid':
+        return faker.string.uuid();
+
+      case 'boolean':
+        return faker.datatype.boolean();
+
+      case 'integer':
+      case 'bigint':
+      case 'smallint':
+        return faker.number.int({
+          min: fieldConfig.min ?? 1,
+          max: fieldConfig.max ?? 100000,
+        });
+
+      case 'decimal':
+      case 'numeric':
+      case 'real':
+      case 'double':
+        return faker.number.float({
+          min: fieldConfig.min ?? 0,
+          max: fieldConfig.max ?? 10000,
+          fractionDigits: fieldConfig.scale ?? 2,
+        });
+
+      case 'varchar':
+      case 'char':
+        return faker.lorem.word().substring(0, fieldConfig.length || 255);
+
+      case 'text':
+        return faker.lorem.paragraph();
+
+      case 'date':
+        return faker.date.past().toISOString().split('T')[0];
+
+      case 'time':
+        return faker.date.recent().toISOString().split('T')[1]?.split('.')[0] ?? '00:00:00';
+
+      case 'timestamp':
+      case 'timestamptz':
+        return faker.date.recent().toISOString();
+
+      case 'json':
+      case 'jsonb':
+        return { data: faker.lorem.word() };
+
+      default:
+        return faker.lorem.word();
+    }
+  }
+
+  private callFakerMethod(method: string): any {
+    const parts = method.split('.');
+    let current: any = faker;
+
+    for (const part of parts) {
+      current = current[part];
+      if (current === undefined) {
+        throw new Error(`Faker method not found: ${method}`);
+      }
+    }
+
+    if (typeof current === 'function') {
+      return current();
+    }
+
+    return current;
+  }
+
+  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
+    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}`);
+    }
+  }
+
+  /**
+   * Gets the generated data without triggering generation.
+   * Must be called after generate().
+   *
+   * @returns The generated data indexed by table name
+   */
+  getGeneratedData(): GeneratedData {
+    return this.generatedData;
+  }
+}