drizzle-multitenant 1.1.0 → 1.3.0

package/dist/scaffold/index.d.ts

@@ -0,0 +1,330 @@
+/**
+ * Scaffold module types
+ *
+ * @module scaffold/types
+ */
+/**
+ * Type of scaffold to generate
+ */
+type ScaffoldType = 'tenant' | 'shared';
+/**
+ * Kind of scaffold template
+ */
+type ScaffoldKind = 'schema' | 'seed' | 'migration';
+/**
+ * Options for scaffolding a schema
+ */
+interface ScaffoldSchemaOptions {
+    /** Name of the schema/table (e.g., "orders", "products") */
+    name: string;
+    /** Type of schema (tenant or shared) */
+    type: ScaffoldType;
+    /** Output directory for the schema file */
+    outputDir?: string;
+    /** Whether to include example columns */
+    includeExample?: boolean;
+    /** Whether to include timestamps (createdAt, updatedAt) */
+    includeTimestamps?: boolean;
+    /** Whether to include soft delete (deletedAt) */
+    includeSoftDelete?: boolean;
+    /** Whether to use UUID for primary key (default: true) */
+    useUuid?: boolean;
+}
+/**
+ * Options for scaffolding a seed
+ */
+interface ScaffoldSeedOptions {
+    /** Name of the seed file (e.g., "initial", "demo-data") */
+    name: string;
+    /** Type of seed (tenant or shared) */
+    type: ScaffoldType;
+    /** Output directory for the seed file */
+    outputDir?: string;
+    /** Optional table name to seed */
+    tableName?: string;
+}
+/**
+ * Options for scaffolding a migration
+ */
+interface ScaffoldMigrationOptions {
+    /** Name of the migration (e.g., "add-orders", "create-users") */
+    name: string;
+    /** Type of migration (tenant or shared) */
+    type: ScaffoldType;
+    /** Output directory for the migration file */
+    outputDir?: string;
+    /** Migration template type */
+    template?: MigrationTemplate;
+}
+/**
+ * Available migration templates
+ */
+type MigrationTemplate = 'create-table' | 'add-column' | 'add-index' | 'add-foreign-key' | 'blank';
+/**
+ * Result of a scaffold operation
+ */
+interface ScaffoldResult {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Path to the generated file */
+    filePath: string;
+    /** Name of the generated file */
+    fileName: string;
+    /** Type of scaffold generated */
+    kind: ScaffoldKind;
+    /** Tenant or shared */
+    type: ScaffoldType;
+    /** Optional error message if failed */
+    error?: string;
+}
+/**
+ * Template context for schema generation
+ */
+interface SchemaTemplateContext {
+    /** Table name in snake_case */
+    tableName: string;
+    /** Table name in PascalCase */
+    tableNamePascal: string;
+    /** Table name in camelCase */
+    tableNameCamel: string;
+    /** Schema type (tenant or shared) */
+    type: ScaffoldType;
+    /** Whether to include timestamps */
+    includeTimestamps: boolean;
+    /** Whether to include soft delete */
+    includeSoftDelete: boolean;
+    /** Whether to use UUID for primary key */
+    useUuid: boolean;
+    /** Whether to include example columns */
+    includeExample: boolean;
+}
+/**
+ * Template context for seed generation
+ */
+interface SeedTemplateContext {
+    /** Seed function name in camelCase */
+    seedName: string;
+    /** Table name (optional) */
+    tableName?: string;
+    /** Schema type (tenant or shared) */
+    type: ScaffoldType;
+}
+/**
+ * Template context for migration generation
+ */
+interface MigrationTemplateContext {
+    /** Migration name for comments */
+    migrationName: string;
+    /** Schema type (tenant or shared) */
+    type: ScaffoldType;
+    /** Template type */
+    template: MigrationTemplate;
+    /** Table name (derived from migration name) */
+    tableName?: string;
+}
+/**
+ * Generated file output
+ */
+interface GeneratedFile {
+    /** File path relative to project root */
+    path: string;
+    /** File content */
+    content: string;
+}
+/**
+ * Scaffold configuration from tenant.config.ts
+ */
+interface ScaffoldConfig {
+    /** Schema output directory */
+    schemaDir?: string;
+    /** Seed output directory */
+    seedDir?: string;
+    /** Migrations folder */
+    migrationsFolder?: string;
+    /** Shared migrations folder */
+    sharedMigrationsFolder?: string;
+}
+
+/**
+ * Scaffold generator
+ *
+ * Orchestrates the generation of schema, seed, and migration files.
+ *
+ * @module scaffold/generator
+ */
+
+/**
+ * Convert a name to various case formats
+ */
+declare function toCase(name: string): {
+    snake: string;
+    pascal: string;
+    camel: string;
+};
+/**
+ * Default output directories
+ */
+declare const DEFAULT_DIRS: {
+    readonly schemaDir: "src/db/schema";
+    readonly seedDir: "drizzle/seeds";
+    readonly tenantMigrationsDir: "drizzle/tenant-migrations";
+    readonly sharedMigrationsDir: "drizzle/shared-migrations";
+};
+/**
+ * Scaffold a new Drizzle schema file
+ *
+ * @param options - Scaffold options
+ * @returns Result of the scaffold operation
+ *
+ * @example
+ * ```typescript
+ * const result = await scaffoldSchema({
+ *   name: 'orders',
+ *   type: 'tenant',
+ *   includeTimestamps: true,
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`Created: ${result.filePath}`);
+ * }
+ * ```
+ */
+declare function scaffoldSchema(options: ScaffoldSchemaOptions): Promise<ScaffoldResult>;
+/**
+ * Scaffold a new seed file
+ *
+ * @param options - Scaffold options
+ * @returns Result of the scaffold operation
+ *
+ * @example
+ * ```typescript
+ * const result = await scaffoldSeed({
+ *   name: 'initial',
+ *   type: 'tenant',
+ *   tableName: 'users',
+ * });
+ * ```
+ */
+declare function scaffoldSeed(options: ScaffoldSeedOptions): Promise<ScaffoldResult>;
+/**
+ * Scaffold a new migration file
+ *
+ * @param options - Scaffold options
+ * @returns Result of the scaffold operation
+ *
+ * @example
+ * ```typescript
+ * const result = await scaffoldMigration({
+ *   name: 'add-orders',
+ *   type: 'tenant',
+ *   template: 'create-table',
+ * });
+ * ```
+ */
+declare function scaffoldMigration(options: ScaffoldMigrationOptions): Promise<ScaffoldResult>;
+/**
+ * Get available migration templates
+ */
+declare function getMigrationTemplates(): Array<{
+    value: MigrationTemplate;
+    label: string;
+    description: string;
+}>;
+
+/**
+ * Schema template generator
+ *
+ * @module scaffold/templates/schema-template
+ */
+
+/**
+ * Generate a Drizzle schema file content
+ *
+ * @param context - Template context
+ * @returns Generated TypeScript code for the schema
+ *
+ * @example
+ * ```typescript
+ * const content = generateSchemaTemplate({
+ *   tableName: 'orders',
+ *   tableNamePascal: 'Orders',
+ *   tableNameCamel: 'orders',
+ *   type: 'tenant',
+ *   includeTimestamps: true,
+ *   includeSoftDelete: false,
+ *   useUuid: true,
+ *   includeExample: true,
+ * });
+ * ```
+ */
+declare function generateSchemaTemplate(context: SchemaTemplateContext): string;
+
+/**
+ * Seed template generator
+ *
+ * @module scaffold/templates/seed-template
+ */
+
+/**
+ * Generate a seed file content
+ *
+ * @param context - Template context
+ * @returns Generated TypeScript code for the seed
+ *
+ * @example
+ * ```typescript
+ * const content = generateSeedTemplate({
+ *   seedName: 'initialData',
+ *   type: 'tenant',
+ *   tableName: 'users',
+ * });
+ * ```
+ */
+declare function generateSeedTemplate(context: SeedTemplateContext): string;
+
+/**
+ * Migration template generator
+ *
+ * @module scaffold/templates/migration-template
+ */
+
+/**
+ * Generate a SQL migration file content
+ *
+ * @param context - Template context
+ * @returns Generated SQL migration content
+ *
+ * @example
+ * ```typescript
+ * const content = generateMigrationTemplate({
+ *   migrationName: 'add-orders',
+ *   type: 'tenant',
+ *   template: 'create-table',
+ *   tableName: 'orders',
+ * });
+ * ```
+ */
+declare function generateMigrationTemplate(context: MigrationTemplateContext): string;
+/**
+ * Infer table name from migration name
+ *
+ * @param migrationName - Name of the migration
+ * @returns Inferred table name or undefined
+ *
+ * @example
+ * ```typescript
+ * inferTableName('add-orders') // 'orders'
+ * inferTableName('create-user-profiles') // 'user_profiles'
+ * inferTableName('add-index-to-users') // 'users'
+ * ```
+ */
+declare function inferTableName(migrationName: string): string | undefined;
+/**
+ * Determine the best template based on migration name
+ *
+ * @param migrationName - Name of the migration
+ * @returns Suggested template type
+ */
+declare function inferMigrationTemplate(migrationName: string): MigrationTemplate;
+
+export { DEFAULT_DIRS, type GeneratedFile, type MigrationTemplate, type MigrationTemplateContext, type ScaffoldConfig, type ScaffoldKind, type ScaffoldMigrationOptions, type ScaffoldResult, type ScaffoldSchemaOptions, type ScaffoldSeedOptions, type ScaffoldType, type SchemaTemplateContext, type SeedTemplateContext, generateMigrationTemplate, generateSchemaTemplate, generateSeedTemplate, getMigrationTemplates, inferMigrationTemplate, inferTableName, scaffoldMigration, scaffoldSchema, scaffoldSeed, toCase };

package/dist/scaffold/index.js

@@ -0,0 +1,277 @@
+import {existsSync}from'fs';import {mkdir,writeFile,readdir}from'fs/promises';import {join,resolve,dirname}from'path';function h(t){let{tableName:e,tableNamePascal:n,tableNameCamel:r,type:i}=t,a=w(t),o=F(t),d=k(t),s=z(t),m=M(t);return `/**
+ * ${n} schema
+ * Type: ${i}
+ *
+ * @module schema/${i}/${r}
+ */
+
+${a}
+
+/**
+ * ${n} table definition
+ */
+export const ${r} = pgTable('${e}', {
+${o}
+});
+
+${d}
+${s}
+${m}
+`}function w(t){let{includeTimestamps:e,includeSoftDelete:n,useUuid:r,includeExample:i}=t,a=["pgTable"];return r?a.push("uuid"):a.push("serial"),a.push("text"),i&&a.push("varchar","boolean"),(e||n)&&a.push("timestamp"),a.push("index"),`import { ${[...new Set(a)].sort().join(", ")} } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod';
+import { z } from 'zod';`}function F(t){let{includeTimestamps:e,includeSoftDelete:n,useUuid:r,includeExample:i}=t,a=[];return r?a.push("  id: uuid('id').primaryKey().defaultRandom(),"):a.push("  id: serial('id').primaryKey(),"),i&&(a.push("  name: varchar('name', { length: 255 }).notNull(),"),a.push("  description: text('description'),"),a.push("  isActive: boolean('is_active').notNull().default(true),")),e&&(a.push("  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),"),a.push("  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),")),n&&a.push("  deletedAt: timestamp('deleted_at', { withTimezone: true }),"),a.join(`
+`)}function k(t){let{tableNameCamel:e,tableName:n,includeExample:r,includeTimestamps:i}=t,a=[];return r&&(a.push(`  nameIdx: index('${n}_name_idx').on(${e}.name),`),a.push(`  isActiveIdx: index('${n}_is_active_idx').on(${e}.isActive),`)),i&&a.push(`  createdAtIdx: index('${n}_created_at_idx').on(${e}.createdAt),`),a.length===0?"":`/**
+ * ${t.tableNamePascal} table indexes
+ */
+export const ${e}Indexes = {
+${a.join(`
+`)}
+};
+`}function z(t){return `// Uncomment and modify to add relations
+// import { relations } from 'drizzle-orm';
+//
+// export const ${t.tableNameCamel}Relations = relations(${t.tableNameCamel}, ({ one, many }) => ({
+//   // Add your relations here
+//   // user: one(users, {
+//   //   fields: [${t.tableNameCamel}.userId],
+//   //   references: [users.id],
+//   // }),
+// }));
+`}function M(t){let{tableNameCamel:e,tableNamePascal:n}=t;return `/**
+ * Zod schemas for validation
+ */
+export const insert${n}Schema = createInsertSchema(${e});
+export const select${n}Schema = createSelectSchema(${e});
+
+/**
+ * TypeScript types inferred from schema
+ */
+export type ${n} = typeof ${e}.$inferSelect;
+export type New${n} = typeof ${e}.$inferInsert;
+
+/**
+ * Zod types
+ */
+export type Insert${n} = z.infer<typeof insert${n}Schema>;
+export type Select${n} = z.infer<typeof select${n}Schema>;
+`}function S(t){let{seedName:e,type:n,tableName:r}=t;return n==="shared"?P(e,r):v(e,r)}function v(t,e){let n=e?`import { ${e} } from '../../src/db/schema/tenant/${e}.js';`:"// import { yourTable } from '../../src/db/schema/tenant/yourTable.js';",r=e?G(e):X();return `/**
+ * Tenant seed: ${t}
+ *
+ * This seed runs in the context of each tenant's schema.
+ * Use this to populate initial data for each tenant.
+ *
+ * @module seeds/tenant/${t}
+ */
+
+import type { SeedFunction } from 'drizzle-multitenant';
+${n}
+
+/**
+ * Seed function that populates tenant data
+ *
+ * @param db - Drizzle database instance scoped to the tenant
+ * @param tenantId - The tenant ID being seeded
+ *
+ * @example
+ * \`\`\`bash
+ * npx drizzle-multitenant seed --file=./drizzle/seeds/tenant/${t}.ts --tenant=my-tenant
+ * \`\`\`
+ */
+export const seed: SeedFunction = async (db, tenantId) => {
+  console.log(\`Seeding tenant: \${tenantId}\`);
+
+${r}
+};
+
+export default seed;
+`}function P(t,e){let n=e?`import { ${e} } from '../../src/db/schema/shared/${e}.js';`:"// import { yourTable } from '../../src/db/schema/shared/yourTable.js';",r=e?B(e):j();return `/**
+ * Shared seed: ${t}
+ *
+ * This seed runs against the shared/public schema.
+ * Use this to populate global data like plans, roles, permissions, etc.
+ *
+ * @module seeds/shared/${t}
+ */
+
+import type { SharedSeedFunction } from 'drizzle-multitenant';
+${n}
+
+/**
+ * Seed function that populates shared data
+ *
+ * @param db - Drizzle database instance for the shared schema
+ *
+ * @example
+ * \`\`\`bash
+ * npx drizzle-multitenant seed:shared --file=./drizzle/seeds/shared/${t}.ts
+ * \`\`\`
+ */
+export const seed: SharedSeedFunction = async (db) => {
+  console.log('Seeding shared schema...');
+
+${r}
+};
+
+export default seed;
+`}function G(t){return `  // Insert data with conflict handling (idempotent)
+  await db.insert(${t}).values([
+    {
+      name: 'Example Item 1',
+      // Add your columns here
+    },
+    {
+      name: 'Example Item 2',
+      // Add your columns here
+    },
+  ]).onConflictDoNothing();
+
+  console.log(\`Seeded ${t} for tenant: \${tenantId}\`);`}function B(t){return `  // Insert data with conflict handling (idempotent)
+  await db.insert(${t}).values([
+    {
+      name: 'Example Item 1',
+      // Add your columns here
+    },
+    {
+      name: 'Example Item 2',
+      // Add your columns here
+    },
+  ]).onConflictDoNothing();
+
+  console.log('Seeded ${t} in shared schema');`}function X(){return `  // Example: Insert initial data
+  // await db.insert(yourTable).values([
+  //   { name: 'Item 1', description: 'Description 1' },
+  //   { name: 'Item 2', description: 'Description 2' },
+  // ]).onConflictDoNothing();
+
+  // You can use tenantId to customize data per tenant
+  // if (tenantId === 'demo-tenant') {
+  //   await db.insert(yourTable).values([
+  //     { name: 'Demo Item', description: 'Only for demo tenant' },
+  //   ]);
+  // }
+
+  console.log(\`Seed completed for tenant: \${tenantId}\`);`}function j(){return `  // Example: Insert shared data like plans, roles, permissions
+  // await db.insert(plans).values([
+  //   { id: 'free', name: 'Free', price: 0 },
+  //   { id: 'pro', name: 'Pro', price: 29 },
+  //   { id: 'enterprise', name: 'Enterprise', price: 99 },
+  // ]).onConflictDoNothing();
+
+  // await db.insert(roles).values([
+  //   { id: 'admin', name: 'Administrator', permissions: ['*'] },
+  //   { id: 'user', name: 'User', permissions: ['read'] },
+  // ]).onConflictDoNothing();
+
+  console.log('Shared seed completed');`}function N(t){let{migrationName:e,type:n,template:r,tableName:i}=t,a=new Date().toISOString(),o=`-- Migration: ${e}
+-- Type: ${n}
+-- Created at: ${a}
+-- Template: ${r}
+
+`;switch(r){case "create-table":return o+K(i);case "add-column":return o+W(i);case "add-index":return o+q(i);case "add-foreign-key":return o+Y(i);default:return o+H()}}function K(t){let e=t||"table_name";return `-- Create table: ${e}
+CREATE TABLE IF NOT EXISTS "${e}" (
+  "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  "name" VARCHAR(255) NOT NULL,
+  "description" TEXT,
+  "is_active" BOOLEAN NOT NULL DEFAULT true,
+  "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  "updated_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Create indexes
+CREATE INDEX IF NOT EXISTS "${e}_name_idx" ON "${e}" ("name");
+CREATE INDEX IF NOT EXISTS "${e}_created_at_idx" ON "${e}" ("created_at");
+
+-- Add updated_at trigger (optional but recommended)
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = NOW();
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS update_${e}_updated_at ON "${e}";
+CREATE TRIGGER update_${e}_updated_at
+  BEFORE UPDATE ON "${e}"
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at_column();
+`}function W(t){let e=t||"table_name";return `-- Add column to: ${e}
+-- ALTER TABLE "${e}" ADD COLUMN "column_name" data_type [constraints];
+
+-- Examples:
+
+-- Add a nullable text column
+-- ALTER TABLE "${e}" ADD COLUMN "notes" TEXT;
+
+-- Add a non-null column with default
+-- ALTER TABLE "${e}" ADD COLUMN "status" VARCHAR(50) NOT NULL DEFAULT 'pending';
+
+-- Add a column with foreign key reference
+-- ALTER TABLE "${e}" ADD COLUMN "user_id" UUID REFERENCES "users" ("id");
+
+-- Add a column with check constraint
+-- ALTER TABLE "${e}" ADD COLUMN "priority" INTEGER CHECK (priority >= 1 AND priority <= 5);
+
+-- Write your column additions below:
+
+`}function q(t){let e=t||"table_name";return `-- Add index to: ${e}
+-- CREATE INDEX [CONCURRENTLY] "index_name" ON "${e}" ("column_name");
+
+-- Examples:
+
+-- Simple index on single column
+-- CREATE INDEX "${e}_column_idx" ON "${e}" ("column_name");
+
+-- Composite index on multiple columns
+-- CREATE INDEX "${e}_col1_col2_idx" ON "${e}" ("column1", "column2");
+
+-- Partial index (filtered)
+-- CREATE INDEX "${e}_active_idx" ON "${e}" ("created_at") WHERE "is_active" = true;
+
+-- Unique index
+-- CREATE UNIQUE INDEX "${e}_email_unique_idx" ON "${e}" ("email");
+
+-- GIN index for full-text search or JSONB
+-- CREATE INDEX "${e}_data_gin_idx" ON "${e}" USING GIN ("data");
+
+-- CONCURRENT index (doesn't lock table, recommended for production)
+-- CREATE INDEX CONCURRENTLY "${e}_column_idx" ON "${e}" ("column_name");
+
+-- Write your indexes below:
+
+`}function Y(t){let e=t||"table_name";return `-- Add foreign key to: ${e}
+-- ALTER TABLE "${e}" ADD CONSTRAINT "fk_name" FOREIGN KEY ("column") REFERENCES "other_table" ("id");
+
+-- Examples:
+
+-- Basic foreign key
+-- ALTER TABLE "${e}" ADD CONSTRAINT "${e}_user_id_fk"
+--   FOREIGN KEY ("user_id") REFERENCES "users" ("id");
+
+-- Foreign key with ON DELETE action
+-- ALTER TABLE "${e}" ADD CONSTRAINT "${e}_user_id_fk"
+--   FOREIGN KEY ("user_id") REFERENCES "users" ("id")
+--   ON DELETE CASCADE;
+
+-- Foreign key with ON UPDATE action
+-- ALTER TABLE "${e}" ADD CONSTRAINT "${e}_category_id_fk"
+--   FOREIGN KEY ("category_id") REFERENCES "categories" ("id")
+--   ON DELETE SET NULL
+--   ON UPDATE CASCADE;
+
+-- Cross-schema foreign key (to shared/public schema)
+-- ALTER TABLE "${e}" ADD CONSTRAINT "${e}_plan_id_fk"
+--   FOREIGN KEY ("plan_id") REFERENCES "public"."plans" ("id");
+
+-- Write your foreign keys below:
+
+`}function H(){return `-- Write your SQL migration here
+
+-- Up migration (apply changes)
+
+
+-- Remember to consider:
+-- 1. Idempotency: Use IF NOT EXISTS / IF EXISTS where possible
+-- 2. Transactions: This will run in a transaction
+-- 3. Rollback: Plan how to undo these changes if needed
+`}function x(t){let e=[/^create[-_](.+)$/i,/^add[-_](.+?)[-_]?(?:table)?$/i,/^(?:add|create)[-_](?:index|fk|constraint)[-_](?:to|on)[-_](.+)$/i,/^(.+?)[-_](?:table|schema)$/i];for(let n of e){let r=t.match(n);if(r?.[1])return r[1].toLowerCase().replace(/[-\s]+/g,"_").replace(/s$/,"")}}function $(t){let e=t.toLowerCase();return e.includes("create")||e.includes("table")?"create-table":e.includes("index")||e.includes("idx")?"add-index":e.includes("fk")||e.includes("foreign")||e.includes("reference")?"add-foreign-key":e.includes("add")||e.includes("column")?"add-column":"blank"}function y(t){let e=t.replace(/([a-z])([A-Z])/g,"$1_$2").replace(/[-\s]+/g,"_").toLowerCase(),n=e.split("_").map(i=>i.charAt(0).toUpperCase()+i.slice(1)).join(""),r=n.charAt(0).toLowerCase()+n.slice(1);return {snake:e,pascal:n,camel:r}}var f={schemaDir:"src/db/schema",seedDir:"drizzle/seeds",tenantMigrationsDir:"drizzle/tenant-migrations",sharedMigrationsDir:"drizzle/shared-migrations"};async function Q(t){let{name:e,type:n,outputDir:r,includeExample:i=true,includeTimestamps:a=true,includeSoftDelete:o=false,useUuid:d=true}=t;try{let s=y(e),m={tableName:s.snake,tableNamePascal:s.pascal,tableNameCamel:s.camel,type:n,includeTimestamps:a,includeSoftDelete:o,useUuid:d,includeExample:i},l=h(m),E=r||join(f.schemaDir,n),p=`${s.camel}.ts`,c=resolve(process.cwd(),E,p);return await mkdir(dirname(c),{recursive:!0}),existsSync(c)?{success:!1,filePath:c,fileName:p,kind:"schema",type:n,error:`File already exists: ${c}`}:(await writeFile(c,l,"utf-8"),{success:!0,filePath:c,fileName:p,kind:"schema",type:n})}catch(s){return {success:false,filePath:"",fileName:"",kind:"schema",type:n,error:s instanceof Error?s.message:String(s)}}}async function V(t){let{name:e,type:n,outputDir:r,tableName:i}=t;try{let a=y(e),o={seedName:a.camel,type:n,...i!==void 0&&{tableName:i}},d=S(o),s=r||join(f.seedDir,n),m=`${a.camel}.ts`,l=resolve(process.cwd(),s,m);return await mkdir(dirname(l),{recursive:!0}),existsSync(l)?{success:!1,filePath:l,fileName:m,kind:"seed",type:n,error:`File already exists: ${l}`}:(await writeFile(l,d,"utf-8"),{success:!0,filePath:l,fileName:m,kind:"seed",type:n})}catch(a){return {success:false,filePath:"",fileName:"",kind:"seed",type:n,error:a instanceof Error?a.message:String(a)}}}async function J(t){let{name:e,type:n,outputDir:r,template:i}=t;try{let a=n==="shared"?f.sharedMigrationsDir:f.tenantMigrationsDir,o=r||a,d=resolve(process.cwd(),o);await mkdir(d,{recursive:!0});let m=(existsSync(d)?await readdir(d):[]).filter(g=>g.endsWith(".sql")),l=0;for(let g of m){let R=g.match(/^(\d+)_/);R?.[1]&&(l=Math.max(l,parseInt(R[1],10)));}let E=(l+1).toString().padStart(4,"0"),p=e.toLowerCase().replace(/[^a-z0-9]+/g,"_").replace(/^_|_$/g,""),c=`${E}_${p}.sql`,u=join(d,c),O=i||$(e),I=x(e),L={migrationName:e,type:n,template:O,...I!==void 0&&{tableName:I}},U=N(L);return existsSync(u)?{success:!1,filePath:u,fileName:c,kind:"migration",type:n,error:`File already exists: ${u}`}:(await writeFile(u,U,"utf-8"),{success:!0,filePath:u,fileName:c,kind:"migration",type:n})}catch(a){return {success:false,filePath:"",fileName:"",kind:"migration",type:n,error:a instanceof Error?a.message:String(a)}}}function ee(){return [{value:"create-table",label:"Create Table",description:"Template for creating a new table with common columns"},{value:"add-column",label:"Add Column",description:"Template for adding columns to an existing table"},{value:"add-index",label:"Add Index",description:"Template for creating indexes"},{value:"add-foreign-key",label:"Add Foreign Key",description:"Template for adding foreign key constraints"},{value:"blank",label:"Blank",description:"Empty migration with basic comments"}]}export{f as DEFAULT_DIRS,N as generateMigrationTemplate,h as generateSchemaTemplate,S as generateSeedTemplate,ee as getMigrationTemplates,$ as inferMigrationTemplate,x as inferTableName,J as scaffoldMigration,Q as scaffoldSchema,V as scaffoldSeed,y as toCase};

package/dist/{types-BhK96FPC.d.ts → types-CGqsPe2Q.d.ts}

@@ -111,6 +111,52 @@ interface DebugContext {
     /** Additional metadata */
     metadata?: Record<string, unknown>;
 }
+/**
+ * Lint rule configuration - can be severity only or [severity, options]
+ */
+type LintRuleConfig<TOptions = Record<string, unknown>> = 'off' | 'warn' | 'error' | ['off' | 'warn' | 'error', TOptions];
+/**
+ * All available lint rules for configuration
+ */
+interface LintRulesConfig {
+    /** Enforce table naming convention (snake_case by default) */
+    'table-naming'?: LintRuleConfig<{
+        style?: 'snake_case' | 'camelCase' | 'PascalCase' | 'kebab-case';
+        exceptions?: string[];
+    }>;
+    /** Enforce column naming convention (snake_case by default) */
+    'column-naming'?: LintRuleConfig<{
+        style?: 'snake_case' | 'camelCase' | 'PascalCase' | 'kebab-case';
+        exceptions?: string[];
+    }>;
+    /** Require every table to have a primary key */
+    'require-primary-key'?: LintRuleConfig;
+    /** Prefer UUID over serial/integer for primary keys */
+    'prefer-uuid-pk'?: LintRuleConfig;
+    /** Require created_at/updated_at columns */
+    'require-timestamps'?: LintRuleConfig<{
+        columns?: string[];
+    }>;
+    /** Require indexes on foreign key columns */
+    'index-foreign-keys'?: LintRuleConfig;
+    /** Warn about CASCADE DELETE on foreign keys */
+    'no-cascade-delete'?: LintRuleConfig;
+    /** Require soft delete column on tables */
+    'require-soft-delete'?: LintRuleConfig<{
+        column?: string;
+    }>;
+}
+/**
+ * Lint configuration
+ */
+interface LintConfig {
+    /** Lint rules configuration */
+    rules?: LintRulesConfig;
+    /** Glob patterns for schema files to include */
+    include?: string[];
+    /** Glob patterns for schema files to exclude */
+    exclude?: string[];
+}
 /**
  * Main configuration interface
  */
@@ -127,6 +173,8 @@ interface Config<TTenantSchema extends Record<string, unknown> = Record<string,
     metrics?: MetricsConfig;
     /** Debug configuration */
     debug?: DebugConfig;
+    /** Schema linting configuration */
+    lint?: LintConfig;
 }
 /**
  * Internal pool entry for LRU cache
@@ -346,4 +394,4 @@ declare const DEFAULT_CONFIG: {
     };
 };
 
-export { type Config as C, type DebugConfig as D, type Hooks as H, type IsolationConfig as I, type MetricsConfig as M, type PoolEntry as P, type RetryConfig as R, type SharedDb as S, type TenantManager as T, type WarmupOptions as W, type TenantDb as a, type ConnectionConfig as b, type IsolationStrategy as c, type SchemasConfig as d, type DebugContext as e, type WarmupResult as f, type TenantWarmupResult as g, type HealthCheckOptions as h, type HealthCheckResult as i, type PoolHealth as j, type PoolHealthStatus as k, type MetricsResult as l, type TenantPoolMetrics as m, type ConnectionMetrics as n, DEFAULT_CONFIG as o };
+export { type Config as C, type DebugConfig as D, type Hooks as H, type IsolationConfig as I, type LintRuleConfig as L, type MetricsConfig as M, type PoolEntry as P, type RetryConfig as R, type SharedDb as S, type TenantManager as T, type WarmupOptions as W, type TenantDb as a, type ConnectionConfig as b, type IsolationStrategy as c, type SchemasConfig as d, type DebugContext as e, type WarmupResult as f, type TenantWarmupResult as g, type HealthCheckOptions as h, type HealthCheckResult as i, type PoolHealth as j, type PoolHealthStatus as k, type MetricsResult as l, type TenantPoolMetrics as m, type ConnectionMetrics as n, type LintRulesConfig as o, type LintConfig as p, DEFAULT_CONFIG as q };