@bunnykit/orm 0.1.24 → 0.1.26

package/dist/src/migration/Migrator.js

@@ -1,5 +1,6 @@
+import { createHash } from "node:crypto";
 import { existsSync } from "fs";
-import { mkdir, readdir, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
 import { basename, join, relative, resolve } from "path";
 import { Schema } from "../schema/Schema.js";
 import { Builder } from "../query/Builder.js";
@@ -10,12 +11,14 @@ export class Migrator {
     path;
     typesOutDir;
     typeGeneratorOptions;
+    options;
     static listeners = new Map();
-    constructor(connection, path, typesOutDir, typeGeneratorOptions = {}) {
+    constructor(connection, path, typesOutDir, typeGeneratorOptions = {}, options = {}) {
         this.connection = connection;
         this.path = path;
         this.typesOutDir = typesOutDir;
         this.typeGeneratorOptions = typeGeneratorOptions;
+        this.options = options;
         Schema.setConnection(connection);
     }
     getPaths() {
@@ -27,10 +30,79 @@ export class Migrator {
             await Schema.create("migrations", (table) => {
                 table.increments("id");
                 table.string("migration");
+                table.string("tenant").nullable().index();
+                table.string("checksum").nullable();
                 table.integer("batch");
             });
+            return;
+        }
+        if (!(await Schema.hasColumn("migrations", "tenant"))) {
+            await Schema.table("migrations", (table) => {
+                table.string("tenant").nullable().index();
+            });
+        }
+        if (!(await Schema.hasColumn("migrations", "checksum"))) {
+            await Schema.table("migrations", (table) => {
+                table.string("checksum").nullable();
+            });
+        }
+    }
+    getTenantId() {
+        return this.options.tenantId ?? null;
+    }
+    scopedMigrations() {
+        const builder = new Builder(this.connection, "migrations");
+        const tenantId = this.getTenantId();
+        return tenantId === null ? builder.whereNull("tenant") : builder.where("tenant", tenantId);
+    }
+    async ensureMigrationLocksTable() {
+        if (await Schema.hasTable("migration_locks"))
+            return;
+        await Schema.create("migration_locks", (table) => {
+            table.string("name").primary();
+            table.string("owner");
+            table.string("created_at");
+        });
+    }
+    getLockName() {
+        const tenantId = this.getTenantId();
+        return tenantId === null ? "migrations:default" : `migrations:tenant:${tenantId}`;
+    }
+    shouldLock() {
+        return this.options.lock !== false;
+    }
+    async acquireLock() {
+        if (!this.shouldLock())
+            return false;
+        await this.ensureMigrationLocksTable();
+        const lockName = this.getLockName();
+        const timeoutMs = this.options.lockTimeoutMs ?? 30000;
+        const owner = `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+        const started = Date.now();
+        while (true) {
+            try {
+                await new Builder(this.connection, "migration_locks").insert({
+                    name: lockName,
+                    owner,
+                    created_at: new Date().toISOString(),
+                });
+                return true;
+            }
+            catch {
+                if (Date.now() - started >= timeoutMs) {
+                    throw new Error(`Could not acquire migration lock "${lockName}" within ${timeoutMs}ms.`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
         }
     }
+    async releaseLock() {
+        if (!this.shouldLock())
+            return;
+        await new Builder(this.connection, "migration_locks")
+            .where("name", this.getLockName())
+            .delete();
+    }
     static on(event, listener) {
         const listeners = this.listeners.get(event) || new Set();
         listeners.add(listener);
@@ -49,7 +121,8 @@ export class Migrator {
         }
     }
     async getLastBatchNumber() {
-        const result = await new Builder(this.connection, "migrations")
+        await this.ensureMigrationsTable();
+        const result = await this.scopedMigrations()
             .select("MAX(batch) as batch")
             .first();
         return result?.batch || 0;
@@ -68,22 +141,29 @@ export class Migrator {
                     id: toPosixPath(relative(process.cwd(), fullPath)),
                     fileName,
                     fullPath,
+                    checksum: await this.checksumFile(fullPath),
                 });
             }
         }
         return files.sort((a, b) => a.fileName.localeCompare(b.fileName) || a.id.localeCompare(b.id));
     }
+    async checksumFile(path) {
+        const contents = await readFile(path);
+        return createHash("sha256").update(contents).digest("hex");
+    }
     async run() {
-        const ran = await this.getRan();
-        const files = await this.getMigrationFiles();
-        const pending = files.filter((f) => !ran.has(f.id) && !ran.has(f.fileName));
-        if (pending.length === 0) {
-            console.log("Nothing to migrate.");
-            return;
-        }
-        const batch = (await this.getLastBatchNumber()) + 1;
-        await this.connection.beginTransaction();
+        await this.ensureMigrationsTable();
+        const locked = await this.acquireLock();
         try {
+            const ran = await this.getRan();
+            const files = await this.getMigrationFiles();
+            const pending = files.filter((f) => !ran.has(f.id) && !ran.has(f.fileName));
+            if (pending.length === 0) {
+                console.log("Nothing to migrate.");
+                return;
+            }
+            const batch = (await this.getLastBatchNumber()) + 1;
+            await this.connection.beginTransaction();
             for (const file of pending) {
                 const migration = await this.resolve(file.id);
                 console.log(`Migrating: ${file.id}`);
@@ -91,6 +171,8 @@ export class Migrator {
                 await migration.up();
                 await new Builder(this.connection, "migrations").insert({
                     migration: file.id,
+                    tenant: this.getTenantId(),
+                    checksum: file.checksum,
                     batch,
                 });
                 await this.emit("migrated", { migration: file.id, batch });
@@ -103,32 +185,38 @@ export class Migrator {
             await this.connection.rollback();
             throw error;
         }
-    }
-    async rollback() {
-        const batch = await this.getLastBatchNumber();
-        if (batch === 0) {
-            console.log("Nothing to rollback.");
-            return;
+        finally {
+            if (locked)
+                await this.releaseLock();
         }
-        const records = (await new Builder(this.connection, "migrations")
-            .where("batch", batch)
-            .orderBy("id", "desc")
-            .get());
-        if (records.length === 0) {
-            console.log("Nothing to rollback.");
-            return;
-        }
-        await this.connection.beginTransaction();
+    }
+    async rollback(steps = 1) {
+        await this.ensureMigrationsTable();
+        const locked = await this.acquireLock();
         try {
+            const batches = await this.getRollbackBatches(steps);
+            if (batches.length === 0) {
+                console.log("Nothing to rollback.");
+                return;
+            }
+            const records = (await this.scopedMigrations()
+                .whereIn("batch", batches)
+                .orderBy("id", "desc")
+                .get());
+            if (records.length === 0) {
+                console.log("Nothing to rollback.");
+                return;
+            }
+            await this.connection.beginTransaction();
             for (const record of records) {
                 const migration = await this.resolve(record.migration);
                 console.log(`Rolling back: ${record.migration}`);
-                await this.emit("rollingBack", { migration: record.migration, batch });
+                await this.emit("rollingBack", { migration: record.migration, batch: record.batch });
                 await migration.down();
                 await new Builder(this.connection, "migrations")
                     .where("id", record.id)
                     .delete();
-                await this.emit("rolledBack", { migration: record.migration, batch });
+                await this.emit("rolledBack", { migration: record.migration, batch: record.batch });
                 console.log(`Rolled back:  ${record.migration}`);
             }
             await this.connection.commit();
@@ -138,6 +226,40 @@ export class Migrator {
             await this.connection.rollback();
             throw error;
         }
+        finally {
+            if (locked)
+                await this.releaseLock();
+        }
+    }
+    async getRollbackBatches(steps) {
+        await this.ensureMigrationsTable();
+        const rows = await this.scopedMigrations()
+            .select("batch")
+            .orderBy("batch", "desc")
+            .get();
+        const batches = [];
+        for (const row of rows) {
+            const batch = Number(row.batch);
+            if (!Number.isFinite(batch) || batches.includes(batch))
+                continue;
+            batches.push(batch);
+            if (batches.length >= steps)
+                break;
+        }
+        return batches;
+    }
+    async reset() {
+        while ((await this.getLastBatchNumber()) > 0) {
+            await this.rollback();
+        }
+    }
+    async refresh() {
+        await this.reset();
+        await this.run();
+    }
+    async fresh() {
+        await this.dropAllTables();
+        await this.run();
     }
     async generateTypesIfNeeded() {
         const modelDirectories = normalizePathList(this.typeGeneratorOptions.modelDirectories || this.typeGeneratorOptions.modelDirectory);
@@ -154,12 +276,21 @@ export class Migrator {
         console.log(`Regenerated types in ${label}`);
     }
     async status() {
-        const ran = await this.getRan();
+        await this.ensureMigrationsTable();
+        const ran = await this.getRanRecords();
         const files = await this.getMigrationFiles();
-        return files.map((file) => ({
-            migration: file.id,
-            status: ran.has(file.id) || ran.has(file.fileName) ? "Ran" : "Pending",
-        }));
+        const tenant = this.getTenantId();
+        return files.map((file) => {
+            const record = ran.get(file.id) || ran.get(file.fileName);
+            const storedChecksum = record?.checksum ?? null;
+            return {
+                migration: file.id,
+                status: !record ? "Pending" : storedChecksum && storedChecksum !== file.checksum ? "Changed" : "Ran",
+                tenant,
+                checksum: file.checksum,
+                storedChecksum,
+            };
+        });
     }
     async dumpSchema(path) {
         const sql = await this.getSchemaDumpSql();
@@ -173,12 +304,21 @@ export class Migrator {
         const files = await this.getMigrationFiles();
         await this.ensureMigrationsTable();
         const batch = (await this.getLastBatchNumber()) + 1;
-        await new Builder(this.connection, "migrations").delete();
-        for (const file of files) {
-            await new Builder(this.connection, "migrations").insert({
-                migration: file.id,
-                batch,
-            });
+        const locked = await this.acquireLock();
+        try {
+            await this.scopedMigrations().delete();
+            for (const file of files) {
+                await new Builder(this.connection, "migrations").insert({
+                    migration: file.id,
+                    tenant: this.getTenantId(),
+                    checksum: file.checksum,
+                    batch,
+                });
+            }
+        }
+        finally {
+            if (locked)
+                await this.releaseLock();
         }
         await this.emit("schemaSquashed", { path, batch });
         return sql;
@@ -242,6 +382,42 @@ export class Migrator {
         }
         return statements.join("\n\n") + "\n";
     }
+    async dropAllTables() {
+        const driver = this.connection.getDriverName();
+        const grammar = this.connection.getGrammar();
+        if (driver === "sqlite") {
+            await this.connection.run("PRAGMA foreign_keys = OFF");
+            try {
+                const rows = await this.connection.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'");
+                for (const row of rows) {
+                    await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(String(row.name))}`);
+                }
+            }
+            finally {
+                await this.connection.run("PRAGMA foreign_keys = ON");
+            }
+            return;
+        }
+        if (driver === "mysql") {
+            const tables = await this.connection.query("SHOW TABLES");
+            const key = Object.keys(tables[0] ?? {})[0];
+            await this.connection.run("SET FOREIGN_KEY_CHECKS = 0");
+            try {
+                for (const row of tables) {
+                    await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(String(row[key]))}`);
+                }
+            }
+            finally {
+                await this.connection.run("SET FOREIGN_KEY_CHECKS = 1");
+            }
+            return;
+        }
+        const schema = this.connection.getSchema() || "public";
+        const tables = await this.connection.query("SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'", [schema]);
+        for (const row of tables) {
+            await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(`${schema}.${row.table_name}`)} CASCADE`);
+        }
+    }
     async resolve(file) {
         const normalized = toPosixPath(file);
         const candidates = new Set();
@@ -268,16 +444,25 @@ export class Migrator {
         return new MigrationClass();
     }
     async getRan() {
+        const results = await this.getRanRecords();
+        const ran = new Set();
+        for (const migration of results.keys()) {
+            ran.add(migration);
+            ran.add(basename(migration));
+        }
+        return ran;
+    }
+    async getRanRecords() {
         await this.ensureMigrationsTable();
-        const results = await new Builder(this.connection, "migrations")
+        const results = await this.scopedMigrations()
             .orderBy("id", "asc")
             .get();
-        const ran = new Set();
+        const records = new Map();
         for (const row of results) {
             const migration = toPosixPath(String(row.migration));
-            ran.add(migration);
-            ran.add(basename(migration));
+            records.set(migration, row);
+            records.set(basename(migration), row);
         }
-        return ran;
+        return records;
     }
 }

package/dist/src/schema/Schema.d.ts

@@ -1,5 +1,19 @@
 import { Connection } from "../connection/Connection.js";
 import { Blueprint } from "./Blueprint.js";
+export interface SchemaIndex {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    primary?: boolean;
+}
+export interface SchemaForeignKey {
+    name?: string;
+    columns: string[];
+    references: string[];
+    onTable: string;
+    onDelete?: string;
+    onUpdate?: string;
+}
 export declare class Schema {
     static connection: Connection;
     static setConnection(connection: Connection): void;
@@ -7,12 +21,22 @@ export declare class Schema {
     private static getGrammar;
     static create(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
     static createIfNotExists(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+    static createSchema(schema: string): Promise<void>;
+    static dropSchema(schema: string, options?: {
+        cascade?: boolean;
+    }): Promise<void>;
     static table(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
     static drop(table: string): Promise<void>;
     static dropIfExists(table: string): Promise<void>;
     static rename(from: string, to: string): Promise<void>;
     static hasTable(table: string): Promise<boolean>;
     static hasColumn(table: string, column: string): Promise<boolean>;
+    static getIndexes(table: string): Promise<SchemaIndex[]>;
+    static hasIndex(table: string, indexOrColumns: string | string[]): Promise<boolean>;
+    static getForeignKeys(table: string): Promise<SchemaForeignKey[]>;
+    static hasForeignKey(table: string, keyOrColumns: string | string[]): Promise<boolean>;
+    private static groupIndexRows;
+    private static groupForeignKeyRows;
     static getColumn(table: string, column: string): Promise<{
         name: string;
         type: string;

package/dist/src/schema/Schema.js

@@ -1,3 +1,4 @@
+import { Connection } from "../connection/Connection.js";
 import { Blueprint } from "./Blueprint.js";
 import { SQLiteGrammar } from "./grammars/SQLiteGrammar.js";
 import { MySqlGrammar } from "./grammars/MySqlGrammar.js";
@@ -61,6 +62,29 @@ export class Schema {
             await this.getConnection().run(fkSql);
         }
     }
+    static async createSchema(schema) {
+        Connection.assertSafeIdentifier(schema, "schema name");
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        if (driver === "sqlite") {
+            throw new Error("Schema creation is not supported for SQLite connections.");
+        }
+        const grammar = this.getGrammar();
+        const keyword = driver === "mysql" ? "DATABASE" : "SCHEMA";
+        await connection.run(`CREATE ${keyword} IF NOT EXISTS ${grammar.wrap(schema)}`);
+    }
+    static async dropSchema(schema, options = {}) {
+        Connection.assertSafeIdentifier(schema, "schema name");
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        if (driver === "sqlite") {
+            throw new Error("Schema dropping is not supported for SQLite connections.");
+        }
+        const grammar = this.getGrammar();
+        const keyword = driver === "mysql" ? "DATABASE" : "SCHEMA";
+        const cascade = driver === "postgres" && options.cascade ? " CASCADE" : "";
+        await connection.run(`DROP ${keyword} IF EXISTS ${grammar.wrap(schema)}${cascade}`);
+    }
     static async table(table, callback) {
         const blueprint = new Blueprint(table);
         callback(blueprint);
@@ -174,6 +198,164 @@ export class Schema {
         const result = await connection.query(sql, bindings);
         return result.length > 0;
     }
+    static async getIndexes(table) {
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const grammar = this.getGrammar();
+        const schema = connection.getSchema() || "public";
+        if (driver === "sqlite") {
+            const indexes = await connection.query(`PRAGMA index_list(${grammar.wrap(table)})`);
+            const results = [];
+            for (const index of indexes) {
+                const name = String(index.name);
+                const columns = await connection.query(`PRAGMA index_info(${grammar.wrap(name)})`);
+                results.push({
+                    name,
+                    columns: columns.map((row) => String(row.name)),
+                    unique: Number(index.unique) === 1,
+                    primary: String(index.origin || "") === "pk",
+                });
+            }
+            return results;
+        }
+        if (driver === "mysql") {
+            const rows = await connection.query(`SELECT index_name, column_name, non_unique
+         FROM information_schema.statistics
+         WHERE table_schema = DATABASE() AND table_name = ?
+         ORDER BY index_name, seq_in_index`, [table]);
+            return this.groupIndexRows(rows, "index_name", "column_name", (row) => Number(row.non_unique) === 0);
+        }
+        const rows = await connection.query(`SELECT
+         i.relname AS index_name,
+         a.attname AS column_name,
+         ix.indisunique AS is_unique,
+         ix.indisprimary AS is_primary,
+         k.ordinality
+       FROM pg_class t
+       JOIN pg_namespace n ON n.oid = t.relnamespace
+       JOIN pg_index ix ON t.oid = ix.indrelid
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ordinality) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+       WHERE n.nspname = $1 AND t.relname = $2
+       ORDER BY i.relname, k.ordinality`, [schema, table]);
+        return this.groupIndexRows(rows, "index_name", "column_name", (row) => !!row.is_unique, (row) => !!row.is_primary);
+    }
+    static async hasIndex(table, indexOrColumns) {
+        const expectedColumns = Array.isArray(indexOrColumns) ? indexOrColumns : undefined;
+        const indexes = await this.getIndexes(table);
+        if (!expectedColumns) {
+            return indexes.some((index) => index.name === indexOrColumns);
+        }
+        return indexes.some((index) => (index.columns.length === expectedColumns.length &&
+            index.columns.every((column, indexPosition) => column === expectedColumns[indexPosition])));
+    }
+    static async getForeignKeys(table) {
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const grammar = this.getGrammar();
+        const schema = connection.getSchema() || "public";
+        if (driver === "sqlite") {
+            const rows = await connection.query(`PRAGMA foreign_key_list(${grammar.wrap(table)})`);
+            const grouped = new Map();
+            for (const row of rows) {
+                const key = String(row.id);
+                const fk = grouped.get(key) || {
+                    name: undefined,
+                    columns: [],
+                    references: [],
+                    onTable: String(row.table),
+                    onDelete: row.on_delete ? String(row.on_delete).toLowerCase() : undefined,
+                    onUpdate: row.on_update ? String(row.on_update).toLowerCase() : undefined,
+                };
+                fk.columns.push(String(row.from));
+                fk.references.push(String(row.to));
+                grouped.set(key, fk);
+            }
+            return [...grouped.values()];
+        }
+        if (driver === "mysql") {
+            const rows = await connection.query(`SELECT
+           k.constraint_name,
+           k.column_name,
+           k.referenced_table_name,
+           k.referenced_column_name,
+           rc.delete_rule,
+           rc.update_rule,
+           k.ordinal_position
+         FROM information_schema.key_column_usage k
+         JOIN information_schema.referential_constraints rc
+           ON rc.constraint_schema = k.constraint_schema
+          AND rc.constraint_name = k.constraint_name
+         WHERE k.table_schema = DATABASE()
+           AND k.table_name = ?
+           AND k.referenced_table_name IS NOT NULL
+         ORDER BY k.constraint_name, k.ordinal_position`, [table]);
+            return this.groupForeignKeyRows(rows, "constraint_name", "column_name", "referenced_table_name", "referenced_column_name", "delete_rule", "update_rule");
+        }
+        const rows = await connection.query(`SELECT
+         tc.constraint_name,
+         kcu.column_name,
+         ccu.table_name AS referenced_table_name,
+         ccu.column_name AS referenced_column_name,
+         rc.delete_rule,
+         rc.update_rule,
+         kcu.ordinal_position
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+       JOIN information_schema.constraint_column_usage ccu
+         ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+       JOIN information_schema.referential_constraints rc
+         ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+       WHERE tc.constraint_type = 'FOREIGN KEY'
+         AND tc.table_schema = $1
+         AND tc.table_name = $2
+       ORDER BY tc.constraint_name, kcu.ordinal_position`, [schema, table]);
+        return this.groupForeignKeyRows(rows, "constraint_name", "column_name", "referenced_table_name", "referenced_column_name", "delete_rule", "update_rule");
+    }
+    static async hasForeignKey(table, keyOrColumns) {
+        const expectedColumns = Array.isArray(keyOrColumns) ? keyOrColumns : undefined;
+        const foreignKeys = await this.getForeignKeys(table);
+        if (!expectedColumns) {
+            return foreignKeys.some((fk) => fk.name === keyOrColumns);
+        }
+        return foreignKeys.some((fk) => (fk.columns.length === expectedColumns.length &&
+            fk.columns.every((column, indexPosition) => column === expectedColumns[indexPosition])));
+    }
+    static groupIndexRows(rows, nameKey, columnKey, unique, primary = () => false) {
+        const grouped = new Map();
+        for (const row of rows) {
+            const name = String(row[nameKey]);
+            const index = grouped.get(name) || { name, columns: [], unique: unique(row), primary: primary(row) };
+            index.columns.push(String(row[columnKey]));
+            index.unique = index.unique || unique(row);
+            index.primary = index.primary || primary(row);
+            grouped.set(name, index);
+        }
+        return [...grouped.values()];
+    }
+    static groupForeignKeyRows(rows, nameKey, columnKey, tableKey, referenceKey, deleteKey, updateKey) {
+        const grouped = new Map();
+        for (const row of rows) {
+            const name = String(row[nameKey]);
+            const fk = grouped.get(name) || {
+                name,
+                columns: [],
+                references: [],
+                onTable: String(row[tableKey]),
+                onDelete: row[deleteKey] ? String(row[deleteKey]).toLowerCase() : undefined,
+                onUpdate: row[updateKey] ? String(row[updateKey]).toLowerCase() : undefined,
+            };
+            fk.columns.push(String(row[columnKey]));
+            fk.references.push(String(row[referenceKey]));
+            grouped.set(name, fk);
+        }
+        return [...grouped.values()];
+    }
     static async getColumn(table, column) {
         const connection = this.getConnection();
         const driver = connection.getDriverName();

package/dist/src/seeding/Factory.d.ts

@@ -0,0 +1,19 @@
+import type { ModelAttributeInput, ModelConstructor } from "../model/Model.js";
+import { Model } from "../model/Model.js";
+export type FactoryDefinition<T extends Model> = (sequence: number) => ModelAttributeInput<T>;
+export type FactoryState<T extends Model> = ModelAttributeInput<T> | ((attributes: ModelAttributeInput<T>, sequence: number) => ModelAttributeInput<T>);
+export declare class Factory<T extends Model> {
+    private model;
+    private definition;
+    private amount;
+    private states;
+    constructor(model: ModelConstructor<T>, definition: FactoryDefinition<T>);
+    count(amount: number): Factory<T>;
+    state(state: FactoryState<T>): Factory<T>;
+    make(overrides?: ModelAttributeInput<T>): T | T[];
+    create(overrides?: ModelAttributeInput<T>): Promise<T | T[]>;
+    raw(overrides?: ModelAttributeInput<T>): ModelAttributeInput<T> | ModelAttributeInput<T>[];
+    private attributesFor;
+    private clone;
+}
+export declare function factory<T extends Model>(model: ModelConstructor<T>, definition: FactoryDefinition<T>): Factory<T>;