@bunnykit/orm 0.1.24 → 0.1.26

package/dist/src/seeding/Factory.js

@@ -0,0 +1,56 @@
+export class Factory {
+    model;
+    definition;
+    amount = 1;
+    states = [];
+    constructor(model, definition) {
+        this.model = model;
+        this.definition = definition;
+    }
+    count(amount) {
+        const next = this.clone();
+        next.amount = Math.max(0, amount);
+        return next;
+    }
+    state(state) {
+        const next = this.clone();
+        next.states = [...next.states, state];
+        return next;
+    }
+    make(overrides = {}) {
+        const models = Array.from({ length: this.amount }, (_, index) => {
+            const attributes = this.attributesFor(index + 1, overrides);
+            return new this.model(attributes);
+        });
+        return this.amount === 1 ? models[0] : models;
+    }
+    async create(overrides = {}) {
+        const records = Array.from({ length: this.amount }, (_, index) => this.attributesFor(index + 1, overrides));
+        const models = [];
+        for (const attributes of records) {
+            models.push(await this.model.create(attributes));
+        }
+        return this.amount === 1 ? models[0] : models;
+    }
+    raw(overrides = {}) {
+        const records = Array.from({ length: this.amount }, (_, index) => this.attributesFor(index + 1, overrides));
+        return this.amount === 1 ? records[0] : records;
+    }
+    attributesFor(sequence, overrides) {
+        let attributes = { ...this.definition(sequence) };
+        for (const state of this.states) {
+            const next = typeof state === "function" ? state(attributes, sequence) : state;
+            attributes = { ...attributes, ...next };
+        }
+        return { ...attributes, ...overrides };
+    }
+    clone() {
+        const next = new Factory(this.model, this.definition);
+        next.amount = this.amount;
+        next.states = [...this.states];
+        return next;
+    }
+}
+export function factory(model, definition) {
+    return new Factory(model, definition);
+}

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

@@ -0,0 +1,16 @@
+import { Connection } from "../connection/Connection.js";
+export declare abstract class Seeder {
+    protected connection: Connection;
+    constructor(connection?: Connection);
+    abstract run(): Promise<void> | void;
+    protected call(seeders: (Seeder | (new (connection?: Connection) => Seeder))[]): Promise<void>;
+}
+export declare class SeederRunner {
+    private connection;
+    constructor(connection?: Connection);
+    run(seeders: (Seeder | (new (connection?: Connection) => Seeder))[]): Promise<void>;
+    runPaths(paths: string | string[]): Promise<void>;
+    runFile(file: string): Promise<void>;
+    runTarget(target: string, searchPaths?: string | string[]): Promise<void>;
+    private getSeederFiles;
+}

package/dist/src/seeding/Seeder.js

@@ -0,0 +1,80 @@
+import { existsSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Schema } from "../schema/Schema.js";
+import { normalizePathList, toPosixPath } from "../utils.js";
+export class Seeder {
+    connection;
+    constructor(connection = Schema.getConnection()) {
+        this.connection = connection;
+    }
+    async call(seeders) {
+        for (const seeder of seeders) {
+            const instance = typeof seeder === "function" ? new seeder(this.connection) : seeder;
+            await instance.run();
+        }
+    }
+}
+export class SeederRunner {
+    connection;
+    constructor(connection = Schema.getConnection()) {
+        this.connection = connection;
+    }
+    async run(seeders) {
+        for (const seeder of seeders) {
+            const instance = typeof seeder === "function" ? new seeder(this.connection) : seeder;
+            await instance.run();
+        }
+    }
+    async runPaths(paths) {
+        const files = await this.getSeederFiles(paths);
+        for (const file of files) {
+            await this.runFile(file);
+        }
+    }
+    async runFile(file) {
+        const resolved = resolve(file);
+        const module = await import(pathToFileURL(resolved).href);
+        const SeederClass = module.default || Object.values(module)[0];
+        if (!SeederClass) {
+            throw new Error(`Seeder ${file} does not export a class.`);
+        }
+        await this.run([SeederClass]);
+    }
+    async runTarget(target, searchPaths = "./database/seeders") {
+        const resolved = resolve(target);
+        if (existsSync(resolved) && (await stat(resolved)).isFile()) {
+            await this.runFile(resolved);
+            return;
+        }
+        const files = await this.getSeederFiles(searchPaths);
+        const normalizedTarget = target.replace(/\.(ts|js|mts|mjs|cts|cjs)$/i, "");
+        const match = files.find((file) => {
+            const name = basename(file, extname(file));
+            return name === normalizedTarget || file.endsWith(target) || file.endsWith(`${target}.ts`) || file.endsWith(`${target}.js`);
+        });
+        if (!match) {
+            throw new Error(`Seeder "${target}" could not be found in ${normalizePathList(searchPaths).join(", ")}.`);
+        }
+        await this.runFile(match);
+    }
+    async getSeederFiles(paths) {
+        const files = [];
+        for (const path of normalizePathList(paths)) {
+            const root = resolve(path);
+            if (!existsSync(root))
+                continue;
+            for (const entry of await readdir(root, { withFileTypes: true })) {
+                if (!entry.isFile())
+                    continue;
+                if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".test.ts") || entry.name.endsWith(".spec.ts"))
+                    continue;
+                if (![".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"].includes(extname(entry.name)))
+                    continue;
+                files.push(toPosixPath(resolve(root, entry.name)));
+            }
+        }
+        return files.sort((a, b) => basename(a).localeCompare(basename(b)) || a.localeCompare(b));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",