drizzle-multitenant 1.2.0 → 1.3.1

package/dist/{migrator-BDgFzSh8.d.ts → migrator-C7FtsZ0H.d.ts}

@@ -1,4 +1,4 @@
-import { C as Config } from './types-BhK96FPC.js';
+import { C as Config } from './types-CGqsPe2Q.js';
 import { Pool } from 'pg';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 
@@ -305,6 +305,35 @@ interface MigratorConfig {
      * @default "name"
      */
     defaultFormat?: TableFormat;
+    /**
+     * Path to shared schema migrations folder
+     * If provided, enables shared schema migration support
+     */
+    sharedMigrationsFolder?: string;
+    /**
+     * Table name for tracking shared migrations
+     * @default "__drizzle_shared_migrations"
+     */
+    sharedMigrationsTable?: string;
+    /**
+     * Hooks for shared schema migrations
+     */
+    sharedHooks?: SharedMigrationHooks;
+    /**
+     * Table format for tracking shared schema migrations
+     * Independent from tenant tableFormat, allowing different formats per schema type
+     * - "auto": Auto-detect existing format, use sharedDefaultFormat for new tables
+     * - "name": Use filename (drizzle-multitenant native)
+     * - "hash": Use SHA-256 hash
+     * - "drizzle-kit": Exact drizzle-kit format (hash + bigint timestamp)
+     * @default "auto"
+     */
+    sharedTableFormat?: 'auto' | TableFormat;
+    /**
+     * When using "auto" for sharedTableFormat and no table exists, which format to create
+     * @default "name"
+     */
+    sharedDefaultFormat?: TableFormat;
 }
 /**
  * Migrate options
@@ -608,6 +637,104 @@ interface SchemaDriftOptions {
     onProgress?: (tenantId: string, status: 'starting' | 'introspecting' | 'comparing' | 'completed' | 'failed') => void;
 }
 
+/**
+ * Migration status for the shared schema (public)
+ */
+interface SharedMigrationStatus {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Number of applied migrations */
+    appliedCount: number;
+    /** Number of pending migrations */
+    pendingCount: number;
+    /** Names of pending migrations */
+    pendingMigrations: string[];
+    /** Overall status */
+    status: 'ok' | 'behind' | 'error';
+    /** Error message if status is 'error' */
+    error?: string;
+    /** Detected table format */
+    format: TableFormat | null;
+}
+/**
+ * Migration result for the shared schema
+ */
+interface SharedMigrationResult {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Whether migration was successful */
+    success: boolean;
+    /** List of applied migration names */
+    appliedMigrations: string[];
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Table format used */
+    format?: TableFormat;
+}
+/**
+ * Shared migration configuration (extends MigratorConfig)
+ */
+interface SharedMigratorConfig {
+    /** Path to shared schema migrations folder */
+    sharedMigrationsFolder: string;
+    /** Table name for tracking shared migrations (default: '__drizzle_shared_migrations') */
+    sharedMigrationsTable?: string;
+    /** Migration hooks for shared schema */
+    hooks?: SharedMigrationHooks;
+    /**
+     * Table format for tracking migrations
+     * @default "auto"
+     */
+    tableFormat?: 'auto' | TableFormat;
+    /**
+     * Default format when creating new table
+     * @default "name"
+     */
+    defaultFormat?: TableFormat;
+}
+/**
+ * Hooks for shared schema migrations
+ */
+interface SharedMigrationHooks {
+    /** Called before starting shared migration */
+    beforeMigration?: () => void | Promise<void>;
+    /** Called after shared migration completes */
+    afterMigration?: (result: SharedMigrationResult) => void | Promise<void>;
+    /** Called before applying a specific migration */
+    beforeApply?: (migrationName: string) => void | Promise<void>;
+    /** Called after applying a specific migration */
+    afterApply?: (migrationName: string, durationMs: number) => void | Promise<void>;
+}
+/**
+ * Options for shared migration operations
+ */
+interface SharedMigrateOptions {
+    /** Dry run mode - show what would be applied without executing */
+    dryRun?: boolean;
+    /** Progress callback */
+    onProgress?: (status: 'starting' | 'migrating' | 'completed' | 'failed', migrationName?: string) => void;
+}
+/**
+ * Seed function signature for shared schema
+ * Called with the shared database instance
+ */
+type SharedSeedFunction<TSchema extends Record<string, unknown> = Record<string, unknown>> = (db: PostgresJsDatabase<TSchema>) => Promise<void>;
+/**
+ * Result of shared schema seeding
+ */
+interface SharedSeedResult {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Whether seeding was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+
 /**
  * Parallel migration engine for multi-tenant applications
  */
@@ -621,6 +748,8 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
     private readonly migrationExecutor;
     private readonly batchExecutor;
     private readonly cloner;
+    private readonly sharedMigrationExecutor;
+    private readonly sharedSeeder;
     constructor(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig);
     /**
      * Migrate all tenants in parallel
@@ -769,6 +898,69 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      * Seed specific tenants with initial data
      */
     seedTenants(tenantIds: string[], seedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Check if shared schema seeding is available
+     *
+     * @returns True if shared schema is configured
+     */
+    hasSharedSeeding(): boolean;
+    /**
+     * Seed the shared schema with initial data
+     *
+     * Seeds the public/shared schema with common data like plans, roles, permissions.
+     * Must have schemas.shared configured in the tenant config.
+     *
+     * @example
+     * ```typescript
+     * if (migrator.hasSharedSeeding()) {
+     *   const result = await migrator.seedShared(async (db) => {
+     *     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([
+     *       { name: 'admin', permissions: ['*'] },
+     *       { name: 'user', permissions: ['read'] },
+     *     ]).onConflictDoNothing();
+     *   });
+     *
+     *   if (result.success) {
+     *     console.log(`Seeded shared schema in ${result.durationMs}ms`);
+     *   }
+     * }
+     * ```
+     */
+    seedShared(seedFn: SharedSeedFunction<TSharedSchema>): Promise<SharedSeedResult>;
+    /**
+     * Seed shared schema first, then all tenants
+     *
+     * Convenience method for the common pattern of seeding shared tables
+     * before tenant tables.
+     *
+     * @example
+     * ```typescript
+     * const result = await migrator.seedAllWithShared(
+     *   async (db) => {
+     *     await db.insert(plans).values([{ id: 'free', name: 'Free' }]);
+     *   },
+     *   async (db, tenantId) => {
+     *     await db.insert(roles).values([{ name: 'admin' }]);
+     *   },
+     *   { concurrency: 10 }
+     * );
+     *
+     * if (result.shared.success) {
+     *   console.log('Shared seeding completed');
+     * }
+     * console.log(`Tenants: ${result.tenants.succeeded}/${result.tenants.total}`);
+     * ```
+     */
+    seedAllWithShared(sharedSeedFn: SharedSeedFunction<TSharedSchema>, tenantSeedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<{
+        shared: SharedSeedResult;
+        tenants: SeedResults;
+    }>;
     /**
      * Load migration files from the migrations folder
      */
@@ -780,6 +972,75 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      * Note: This method is shared with SyncManager and MigrationExecutor via dependency injection.
      */
     private getOrDetectFormat;
+    /**
+     * Load shared migration files from the shared migrations folder
+     */
+    private loadSharedMigrations;
+    /**
+     * Get or detect the format for the shared schema
+     *
+     * Uses sharedTableFormat/sharedDefaultFormat if configured,
+     * otherwise falls back to tableFormat/defaultFormat for backwards compatibility.
+     */
+    private getOrDetectSharedFormat;
+    /**
+     * Check if shared schema migrations are configured
+     *
+     * @returns True if sharedMigrationsFolder is configured and exists
+     */
+    hasSharedMigrations(): boolean;
+    /**
+     * Migrate the shared schema (public)
+     *
+     * Applies pending migrations to the shared/public schema.
+     * Must have sharedMigrationsFolder configured.
+     *
+     * @example
+     * ```typescript
+     * if (migrator.hasSharedMigrations()) {
+     *   const result = await migrator.migrateShared();
+     *   console.log(`Applied ${result.appliedMigrations.length} shared migrations`);
+     * }
+     * ```
+     */
+    migrateShared(options?: SharedMigrateOptions): Promise<SharedMigrationResult>;
+    /**
+     * Get migration status for the shared schema
+     *
+     * @returns Status with applied/pending counts
+     */
+    getSharedStatus(): Promise<SharedMigrationStatus>;
+    /**
+     * Mark shared schema migrations as applied without executing SQL
+     *
+     * Useful for syncing tracking state with already-applied migrations.
+     */
+    markSharedAsApplied(options?: {
+        onProgress?: SharedMigrateOptions['onProgress'];
+    }): Promise<SharedMigrationResult>;
+    /**
+     * Migrate shared schema first, then all tenants
+     *
+     * Convenience method for the common pattern of migrating shared tables
+     * before tenant tables.
+     *
+     * @example
+     * ```typescript
+     * const result = await migrator.migrateAllWithShared({
+     *   concurrency: 10,
+     *   onProgress: (tenantId, status) => console.log(`${tenantId}: ${status}`),
+     * });
+     *
+     * console.log(`Shared: ${result.shared.appliedMigrations.length} applied`);
+     * console.log(`Tenants: ${result.tenants.succeeded}/${result.tenants.total} succeeded`);
+     * ```
+     */
+    migrateAllWithShared(options?: MigrateOptions & {
+        sharedOptions?: SharedMigrateOptions;
+    }): Promise<{
+        shared: SharedMigrationResult;
+        tenants: MigrationResults;
+    }>;
     /**
      * Detect schema drift across all tenants
      * Compares each tenant's schema against a reference tenant (first tenant by default)
@@ -821,4 +1082,4 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
  */
 declare function createMigrator<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>>(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig): Migrator<TTenantSchema, TSharedSchema>;
 
-export { type AppliedMigration as A, type TableFormat as B, type CreateTenantOptions as C, type DropTenantOptions as D, type ColumnInfo as E, type ConstraintInfo as F, type TableSchema as G, type TenantSchema as H, type IndexInfo as I, type ColumnDrift as J, type IndexDrift as K, type ConstraintDrift as L, Migrator as M, type TableDrift as N, type TenantSchemaDrift as O, type SchemaDriftStatus as P, type SchemaDriftOptions as Q, type CloneProgressCallback as R, type SeedFunction as S, type TenantMigrationResult as T, type CloneProgressStatus as U, type AnonymizeOptions as V, type AnonymizeRules as W, type AnonymizeValue as X, type MigratorConfig as a, type MigrationFile as b, createMigrator as c, type MigrateOptions as d, type MigrationResults as e, type TenantMigrationStatus as f, type MigrationHooks as g, type MigrationProgressCallback as h, type MigrationErrorHandler as i, type SeedOptions as j, type TenantSeedResult as k, type SeedResults as l, type DetectedFormat as m, type SyncStatus as n, type TenantSyncStatus as o, type TenantSyncResult as p, type SyncOptions as q, type SyncResults as r, type ClonerConfig as s, type ClonerDependencies as t, type CloneTenantOptions as u, type CloneTenantResult as v, detectTableFormat as w, getFormatConfig as x, DEFAULT_FORMAT as y, DRIZZLE_KIT_FORMAT as z };
+export { type AnonymizeRules as $, type AppliedMigration as A, type SharedMigrationStatus as B, type CreateTenantOptions as C, type DropTenantOptions as D, detectTableFormat as E, getFormatConfig as F, DEFAULT_FORMAT as G, DRIZZLE_KIT_FORMAT as H, type TableFormat as I, type ColumnInfo as J, type IndexInfo as K, type ConstraintInfo as L, Migrator as M, type TableSchema as N, type TenantSchema as O, type ColumnDrift as P, type IndexDrift as Q, type ConstraintDrift as R, type SeedFunction as S, type TenantMigrationResult as T, type TableDrift as U, type TenantSchemaDrift as V, type SchemaDriftStatus as W, type SchemaDriftOptions as X, type CloneProgressCallback as Y, type CloneProgressStatus as Z, type AnonymizeOptions as _, type MigratorConfig as a, type AnonymizeValue as a0, type SharedMigratorConfig as a1, type SharedMigrationHooks as a2, type MigrationFile as b, createMigrator as c, type MigrateOptions as d, type MigrationResults as e, type TenantMigrationStatus as f, type MigrationHooks as g, type MigrationProgressCallback as h, type MigrationErrorHandler as i, type SeedOptions as j, type TenantSeedResult as k, type SeedResults as l, type SharedSeedFunction as m, type SharedSeedResult as n, type DetectedFormat as o, type SyncStatus as p, type TenantSyncStatus as q, type TenantSyncResult as r, type SyncOptions as s, type SyncResults as t, type ClonerConfig as u, type ClonerDependencies as v, type CloneTenantOptions as w, type CloneTenantResult as x, type SharedMigrateOptions as y, type SharedMigrationResult as z };

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 };