@h3ravel/arquebus 0.5.0 → 0.6.1

package/dist/seeders/index.js

@@ -0,0 +1,118 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "path";
+import path$1, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/seeders/seeder.ts
+var Seeder = class {};
+var seeder_default = Seeder;
+
+//#endregion
+//#region src/seeders/runner.ts
+async function glob(folderPath) {
+	const { default: escalade } = await import("escalade");
+	const entries = [];
+	await escalade(folderPath, async (dir, names) => {
+		await Promise.all(names.map(async (name) => {
+			const p = path.join(dir, name);
+			try {
+				await access(p);
+				if (p.endsWith(".js") || p.endsWith(".ts")) entries.push(p);
+			} catch {}
+		}));
+		return "";
+	});
+	return entries;
+}
+var SeederRunner = class {
+	resolver;
+	connection;
+	paths = [];
+	constructor(resolver) {
+		this.resolver = resolver;
+	}
+	path(p) {
+		this.paths = Array.from(new Set([...this.paths, p]));
+	}
+	getPaths() {
+		return this.paths;
+	}
+	resolveConnection(connection) {
+		var _getInstance, _ref, _instance$connections;
+		const name = connection || this.connection || "default";
+		const instance = ((_getInstance = (_ref = this.resolver).getInstance) === null || _getInstance === void 0 ? void 0 : _getInstance.call(_ref)) ?? null;
+		if (!!!(instance === null || instance === void 0 || (_instance$connections = instance.connections) === null || _instance$connections === void 0 ? void 0 : _instance$connections[name])) this.resolver.autoLoad().catch(() => {
+			/** noop */
+		});
+		return this.resolver.fire(name);
+	}
+	setConnection(connection) {
+		this.connection = connection;
+		return this;
+	}
+	async getSeederFiles(paths) {
+		const files = [];
+		for (const p of paths) {
+			if (p.endsWith(".js") || p.endsWith(".ts")) {
+				files.push(p);
+				continue;
+			}
+			files.push(...await glob(p));
+		}
+		return files;
+	}
+	async resolvePath(filePath) {
+		try {
+			const mod = await import(filePath);
+			return new (mod.default ?? mod.Seeder)();
+		} catch {
+			return null;
+		}
+	}
+	async run(paths, connection) {
+		const files = await this.getSeederFiles(paths);
+		const conn = this.resolveConnection(connection);
+		for (const file of files) {
+			const seeder = await this.resolvePath(file);
+			if (seeder && typeof seeder.run === "function") await seeder.run(conn);
+		}
+	}
+};
+var runner_default = SeederRunner;
+
+//#endregion
+//#region node_modules/.pnpm/tsdown@0.15.6_typescript@5.9.3/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path$1.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+
+//#endregion
+//#region src/seeders/seeder-creator.ts
+var SeederCreator = class {
+	constructor(customStubPath) {
+		this.customStubPath = customStubPath;
+	}
+	async create(dir, name, type = "js") {
+		await mkdir(dir, { recursive: true });
+		const stubPath = this.getStubPath(type);
+		let stub = await readFile(stubPath, "utf-8");
+		stub = stub.replace(/{{ name }}/g, name);
+		const filePath = path.join(dir, `${name}.${type}`);
+		await writeFile(filePath, stub);
+		return filePath;
+	}
+	getStubPath(type) {
+		if (this.customStubPath) return path.join(this.customStubPath, `seeder-${type}.stub`);
+		const __dirname$1 = this.getDirname(import.meta);
+		return path.join(__dirname$1, "stubs", `seeder-${type}.stub`);
+	}
+	getDirname(meta) {
+		if (typeof __dirname !== "undefined") return __dirname;
+		if (meta && meta.url) return dirname(fileURLToPath(meta.url));
+		throw new Error("Unable to determine dirname");
+	}
+};
+var seeder_creator_default = SeederCreator;
+
+//#endregion
+export { seeder_default as Seeder, seeder_creator_default as SeederCreator, runner_default as SeederRunner };

package/dist/seeders/index.ts

@@ -0,0 +1,3 @@
+export { default as Seeder } from './seeder'
+export { default as SeederRunner } from './runner'
+export { default as SeederCreator } from './seeder-creator'

package/dist/seeders/runner.ts

@@ -0,0 +1,101 @@
+import type QueryBuilder from 'src/query-builder'
+import type Seeder from './seeder'
+import type { TBaseConfig } from 'types/container'
+import { access } from 'node:fs/promises'
+import type { arquebus } from 'src'
+import path from 'path'
+
+async function glob (folderPath: string): Promise<string[]> {
+  const { default: escalade } = await import('escalade')
+  const entries: string[] = []
+  const root = folderPath
+  await escalade(root, async (dir, names) => {
+    await Promise.all(
+      names.map(async (name) => {
+        const p = path.join(dir, name)
+        try {
+          await access(p)
+          if (p.endsWith('.js') || p.endsWith('.ts')) entries.push(p)
+        } catch {
+          /** */
+        }
+      }),
+    )
+    return ''
+  })
+  return entries
+}
+
+export class SeederRunner {
+  resolver: typeof arquebus
+  connection!: TBaseConfig['client']
+  paths: string[] = []
+
+  constructor(resolver: typeof arquebus) {
+    this.resolver = resolver
+  }
+
+  path (p: string): void {
+    this.paths = Array.from(new Set([...this.paths, p]))
+  }
+
+  getPaths (): string[] {
+    return this.paths
+  }
+
+  resolveConnection (connection?: TBaseConfig['client']): QueryBuilder {
+    const name = connection || this.connection || 'default'
+    // If the resolver has no connection manager entry, attempt to autoload config
+    const instance: any = (this.resolver as any).getInstance?.() ?? null
+    const hasConn = !!instance?.connections?.[name]
+    if (!hasConn) {
+      // Attempt autoload; do not throw if empty
+      this.resolver
+        .autoLoad()
+        .catch(() => {
+          /** noop */
+        })
+    }
+    return this.resolver.fire(name)
+  }
+
+  setConnection (connection: TBaseConfig['client']): this {
+    this.connection = connection
+    return this
+  }
+
+  async getSeederFiles (paths: string[]): Promise<string[]> {
+    const files: string[] = []
+    for (const p of paths) {
+      if (p.endsWith('.js') || p.endsWith('.ts')) {
+        files.push(p)
+        continue
+      }
+      files.push(...(await glob(p)))
+    }
+    return files
+  }
+
+  async resolvePath (filePath: string): Promise<Seeder | null> {
+    try {
+      const mod = await import(filePath)
+      const instance = new (mod.default ?? mod.Seeder)()
+      return instance as Seeder
+    } catch {
+      return null
+    }
+  }
+
+  async run (paths: string[], connection?: TBaseConfig['client']): Promise<void> {
+    const files = await this.getSeederFiles(paths)
+    const conn = this.resolveConnection(connection)
+    for (const file of files) {
+      const seeder = await this.resolvePath(file)
+      if (seeder && typeof seeder.run === 'function') {
+        await seeder.run(conn)
+      }
+    }
+  }
+}
+
+export default SeederRunner

package/dist/seeders/seeder-creator.ts

@@ -0,0 +1,42 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import path from 'path'
+
+export class SeederCreator {
+  constructor(private customStubPath?: string) { }
+
+  async create (dir: string, name: string, type: 'js' | 'ts' = 'js') {
+    await mkdir(dir, { recursive: true })
+
+    const stubPath = this.getStubPath(type)
+    let stub = await readFile(stubPath, 'utf-8')
+    stub = stub.replace(/{{ name }}/g, name)
+
+    const filePath = path.join(dir, `${name}.${type}`)
+    await writeFile(filePath, stub)
+
+    return filePath
+  }
+
+  getStubPath (type: 'js' | 'ts') {
+    if (this.customStubPath) return path.join(this.customStubPath, `seeder-${type}.stub`)
+    const __dirname = this.getDirname(import.meta as any)
+    return path.join(__dirname, 'stubs', `seeder-${type}.stub`)
+  }
+
+  getDirname (meta: ImportMeta | null) {
+    if (typeof __dirname !== 'undefined') {
+      // CJS build
+      return __dirname
+    }
+    if (meta && meta.url) {
+      // ESM build 
+      return dirname(fileURLToPath(meta.url))
+    }
+    throw new Error('Unable to determine dirname')
+  }
+}
+
+export default SeederCreator

package/dist/seeders/seeder.ts

@@ -0,0 +1,10 @@
+import type QueryBuilder from 'src/query-builder'
+
+export abstract class Seeder {
+  /**
+   * Run the database seeds
+   */
+  abstract run(connection: QueryBuilder): Promise<void>
+}
+
+export default Seeder

package/dist/stubs/seeder-js.stub

@@ -0,0 +1,13 @@
+import { Seeder } from '@h3ravel/arquebus'
+
+export default class {{ name }} extends Seeder {
+  /**
+    * Run the seeder.
+    * 
+    * @param {(import('@h3ravel/arquebus').QueryBuilder)} connection 
+    */
+  async run(connection) {
+    // Example: insert sample data
+    await connection.table('users').insert({ name: 'John Doe' })
+  }
+}

package/dist/stubs/seeder-ts.stub

@@ -0,0 +1,9 @@
+import type { QueryBuilder } from '@h3ravel/arquebus'
+import { Seeder } from '@h3ravel/arquebus'
+
+export default class {{ name }} extends Seeder {
+  async run(connection: QueryBuilder) {
+    // Example: insert sample data
+    await connection.table('users').insert({ name: 'John Doe' })
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h3ravel/arquebus",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Arquebus ORM is a Beautiful, expressive ORM inspired by Laravel's Eloquent, designed for TypeScript applications and for the H3ravel Framework.",
   "homepage": "https://h3ravel.toneflix.net/arquebus",
   "bin": {
@@ -91,6 +91,16 @@
         "default": "./dist/inspector/index.cjs"
       }
     },
+    "./seeders": {
+      "import": {
+        "types": "./dist/seeders/index.d.ts",
+        "default": "./dist/seeders/index.js"
+      },
+      "require": {
+        "types": "./dist/seeders/index.d.cts",
+        "default": "./dist/seeders/index.cjs"
+      }
+    },
     "./browser": {
       "import": {
         "types": "./dist/browser/index.d.ts",
@@ -123,7 +133,8 @@
     ]
   },
   "dependencies": {
-    "@h3ravel/shared": "^0.20.1",
+    "@h3ravel/shared": "^0.20.12",
+    "@h3ravel/support": "^0.12.0",
     "chalk": "^5.6.2",
     "collect.js": "^4.36.1",
     "commander": "^14.0.1",
@@ -137,7 +148,6 @@
     "mysql2": "^3.15.0",
     "pg": "^8.16.3",
     "pluralize": "^8.0.0",
-    "prettier": "^3.6.2",
     "radashi": "^12.6.2",
     "resolve-from": "^5.0.0",
     "tedious": "^19.0.0"
@@ -151,6 +161,7 @@
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.36.0",
     "jsdom": "^26.1.0",
+    "prettier": "^3.6.2",
     "sqlite3": "5.1.7",
     "terser": "^5.44.0",
     "ts-node": "^10.9.2",

package/types/builder.ts

@@ -10,90 +10,163 @@ import type Model from 'src/model'
 import type { TFunction } from './generics'
 
 type BaseBuilder<M extends Model | BModel, R = ICollection<M> | IModel> = Omit<
-    IQueryBuilder<M, R>,
-    'destroy' | 'clone' | 'get' | 'skip' | 'limit' | 'take' | 'offset' | 'chunk' | 'forPage' | 'orWhere' | 'pluck'
+  IQueryBuilder<M, R>,
+  | 'destroy'
+  | 'clone'
+  | 'get'
+  | 'skip'
+  | 'limit'
+  | 'take'
+  | 'offset'
+  | 'chunk'
+  | 'forPage'
+  | 'orWhere'
+  | 'pluck'
 >
 
 export interface IScope {
-    apply (builder: Builder<any>, model: Model): void;
+  apply(builder: Builder<any>, model: Model): void
 }
 
 // @ts-expect-error Errors will come from builder differences but that is fine
-export interface IBuilder<M extends Model | BModel, R = ICollection<M> | IModel> extends BaseBuilder<M, R> {
-    connector: IQueryBuilder<M, R> & Knex.QueryBuilder & { _statements: any[], _single: any } & Knex
-    asProxy (): IQueryBuilder<M, R>;
-    chunk (count: number, callback: (rows: ICollection<M>) => any): Promise<boolean>;
-    enforceOrderBy (): void;
-    idOf (id: string | number): this;
-    clone (): IBuilder<M, R>;
-    forPage (page: number, perPage?: number): this;
-    insert (...attributes: any[]): Promise<any>;
-    update (attributes: any): Promise<any>;
-    increment (column: string, amount?: number, extra?: any): Promise<any>;
-    decrement (column: string, amount?: number, extra?: any): Promise<any>;
-    addUpdatedAtColumn (values: any): any;
-    delete (): Promise<boolean | number>;
-    softDelete (): boolean | Promise<any>;
-    forceDelete (): boolean | Promise<any>;
-    restore (): boolean | Promise<any>;
-    withTrashed (): this;
-    withoutTrashed (): this;
-    onlyTrashed (): this;
-    getDeletedAtColumn (): string;
-    create (attributes?: any): Promise<M>;
-    newModelInstance (attributes?: any): M;
-    count (columns?: string): Promise<number>;
-    getQuery (): AnyQueryBuilder;
-    getModel (): M;
-    setModel (model: M): this;
-    setTable (table: string): this;
-    applyScopes (): this;
-    scopes (scopes: string[]): this;
-    withGlobalScope (identifier: string | number, scope: string | (() => void)): this;
-    withoutGlobalScope (scope: IScope | string): this;
-    with (relation: WithRelationType): this;
-    with (...relations: WithRelationType[]): this;
-    has (relation: string, operator?: any, count?: number, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
-    orHas (relation: string, operator?: any, count?: number): this;
-    doesntHave (relation: string, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
-    orDoesntHave (relation: string): this;
-    whereHas (relation: string, callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null, operator?: any, count?: number): this;
-    orWhere (...args: any[]): this
-    orWhereHas (relation: string, callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null, operator?: any, count?: number): this;
-    whereRelation (relation: string, column: string, operator?: any, value?: any): this;
-    hasNested (relation: string, operator?: any, count?: number, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
-    canUseExistsForExistenceCheck (operator: string, count: number): boolean;
-    addHasWhere (hasQuery: IBuilder<any>, relation: string, operator?: string, count?: number, boolean?: string): this;
-    withAggregate (relations: string | string[] | object, column: string, action?: string | null): this;
-    toSql (): object;
-    withCount (...relations: WithRelationType[]): this;
-    withMax (relation: WithRelationType, column: string): this;
-    withMin (relation: WithRelationType, column: string): this;
-    withAvg (relation: WithRelationType, column: string): this;
-    withSum (relation: WithRelationType, column: string): this;
-    withExists (relation: WithRelationType): this;
-    related (relation: string): this;
-    take (count: number): this;
-    skip (count: number): this;
-    limit (count: number): this;
-    offset (count: number): this;
-    first (column?: string | string[]): Promise<M | null | undefined>;
-    firstOrFail (column?: string | string[]): Promise<M>;
-    findOrFail (key: string | number, columns?: string[]): Promise<M>;
-    findOrFail (key: string[] | number[] | ICollection<any>, columns?: string[]): Promise<M>;
-    findOrFail (key: string | number | string[] | number[] | ICollection<any>, columns?: string[]): Promise<M>;
-    findOrNew (id: string | number, columns?: string[]): Promise<M>;
-    firstOrNew (attributes?: object, values?: object): Promise<M>;
-    firstOrCreate (attributes?: object, values?: object): Promise<M>;
-    updateOrCreate (attributes: object, values?: object): Promise<M>;
-    latest (column?: string): this;
-    oldest (column?: string): this;
-    find (key: string | number, columns?: string[]): Promise<M | null | undefined>;
-    findMany (keys: string[] | number[] | ICollection<any>, columns?: string[]): Promise<ICollection<M>>;
-    pluck<X extends Model = any | M> (column: string): Promise<ICollection<X>>;
-    destroy (ids?: string | number | string[] | number[] | TFunction | ICollection<any>): Promise<number>;
-    get (columns?: string[]): Promise<ICollection<M>>;
-    all (columns?: string[]): Promise<ICollection<M>>;
-    paginate<F extends IPaginatorParams> (page?: number, perPage?: number): Promise<IPaginator<M, F>>;
-    [value: string]: any;
+export interface IBuilder<M extends Model | BModel, R = ICollection<M> | IModel>
+  extends BaseBuilder<M, R> {
+  connector: IQueryBuilder<M, R> &
+    Knex.QueryBuilder & { _statements: any[]; _single: any } & Knex
+  asProxy(): IQueryBuilder<M, R>
+  chunk(
+    count: number,
+    callback: (rows: ICollection<M>) => any,
+  ): Promise<boolean>
+  enforceOrderBy(): void
+  idOf(id: string | number): this
+  clone(): IBuilder<M, R>
+  forPage(page: number, perPage?: number): this
+  insert(...attributes: any[]): Promise<any>
+  update(attributes: any): Promise<any>
+  increment(column: string, amount?: number, extra?: any): Promise<any>
+  decrement(column: string, amount?: number, extra?: any): Promise<any>
+  addUpdatedAtColumn(values: any): any
+  delete(): Promise<boolean | number>
+  softDelete(): boolean | Promise<any>
+  forceDelete(): boolean | Promise<any>
+  restore(): boolean | Promise<any>
+  withTrashed(): this
+  withoutTrashed(): this
+  onlyTrashed(): this
+  getDeletedAtColumn(): string
+  create(attributes?: any): Promise<M>
+  newModelInstance(attributes?: any): M
+  count(columns?: string): Promise<number>
+  getQuery(): AnyQueryBuilder
+  getModel(): M
+  setModel(model: M): this
+  setTable(table: string): this
+  applyScopes(): this
+  scopes(scopes: string[]): this
+  withGlobalScope(
+    identifier: string | number,
+    scope: string | (() => void),
+  ): this
+  withoutGlobalScope(scope: IScope | string): this
+  with(relation: WithRelationType): this
+  with(...relations: WithRelationType[]): this
+  has(
+    relation: string,
+    operator?: any,
+    count?: number,
+    boolean?: any,
+    callback?: (builder: IBuilder<any>) => void | null,
+  ): this
+  orHas(relation: string, operator?: any, count?: number): this
+  doesntHave(
+    relation: string,
+    boolean?: any,
+    callback?: (builder: IBuilder<any>) => void | null,
+  ): this
+  orDoesntHave(relation: string): this
+  whereHas(
+    relation: string,
+    callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null,
+    operator?: any,
+    count?: number,
+  ): this
+  orWhere(...args: any[]): this
+  orWhereHas(
+    relation: string,
+    callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null,
+    operator?: any,
+    count?: number,
+  ): this
+  whereRelation(
+    relation: string,
+    column: string,
+    operator?: any,
+    value?: any,
+  ): this
+  hasNested(
+    relation: string,
+    operator?: any,
+    count?: number,
+    boolean?: any,
+    callback?: (builder: IBuilder<any>) => void | null,
+  ): this
+  canUseExistsForExistenceCheck(operator: string, count: number): boolean
+  addHasWhere(
+    hasQuery: IBuilder<any>,
+    relation: string,
+    operator?: string,
+    count?: number,
+    boolean?: string,
+  ): this
+  withAggregate(
+    relations: string | string[] | object,
+    column: string,
+    action?: string | null,
+  ): this
+  toSql(): object
+  withCount(...relations: WithRelationType[]): this
+  withMax(relation: WithRelationType, column: string): this
+  withMin(relation: WithRelationType, column: string): this
+  withAvg(relation: WithRelationType, column: string): this
+  withSum(relation: WithRelationType, column: string): this
+  withExists(relation: WithRelationType): this
+  related(relation: string): this
+  take(count: number): this
+  skip(count: number): this
+  limit(count: number): this
+  offset(count: number): this
+  first(column?: string | string[]): Promise<M | null | undefined>
+  firstOrFail(column?: string | string[]): Promise<M>
+  findOrFail(key: string | number, columns?: string[]): Promise<M>
+  findOrFail(
+    key: string[] | number[] | ICollection<any>,
+    columns?: string[],
+  ): Promise<M>
+  findOrFail(
+    key: string | number | string[] | number[] | ICollection<any>,
+    columns?: string[],
+  ): Promise<M>
+  findOrNew(id: string | number, columns?: string[]): Promise<M>
+  firstOrNew(attributes?: object, values?: object): Promise<M>
+  firstOrCreate(attributes?: object, values?: object): Promise<M>
+  updateOrCreate(attributes: object, values?: object): Promise<M>
+  latest(column?: string): this
+  oldest(column?: string): this
+  find(key: string | number, columns?: string[]): Promise<M | null | undefined>
+  findMany(
+    keys: string[] | number[] | ICollection<any>,
+    columns?: string[],
+  ): Promise<ICollection<M>>
+  pluck<X extends Model = any | M>(column: string): Promise<ICollection<X>>
+  destroy(
+    ids?: string | number | string[] | number[] | TFunction | ICollection<any>,
+  ): Promise<number>
+  get(columns?: string[]): Promise<ICollection<M>>
+  all(columns?: string[]): Promise<ICollection<M>>
+  paginate<F extends IPaginatorParams>(
+    page?: number,
+    perPage?: number,
+  ): Promise<IPaginator<M, F>>
+  [value: string]: any
 }