peta-orm 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -7,6 +7,7 @@ import { a as getRawRelations, d as setExists, o as getState } from "./state-Ltl
 import { a as setConfig$1, n as reloadModel, r as saveModel, t as getConfig$1 } from "./save-D5UKXvqC.mjs";
 import { type } from "arktype";
 import { Kysely, sql } from "kysely";
+import { pathToFileURL } from "url";
 import { ulid as ulid$1 } from "ulid";
 //#region src/columns/arktype.ts
 function createArkTypeSchemaConfig() {
@@ -189,7 +190,27 @@ function createColumn(schema, dataType, args = [], constraints = []) {
 }
 //#endregion
 //#region src/columns/types.ts
-function t(config) {
+/**
+* Pre-configured column type factory backed by ArkType validation.
+*
+* The most common usage — just import and use:
+* ```ts
+* import { t } from "peta-orm"
+* const id = t.integer().primaryKey()
+* ```
+*
+* For a custom validation backend, use `createColumnTypes({ schema })` instead.
+*/
+const t = createColumnTypes({ schema: createArkTypeSchemaConfig() });
+/**
+* Create a column type factory with a custom validation schema backend.
+*
+* @example
+* ```ts
+* const t = createColumnTypes({ schema: myCustomSchemaConfig })
+* ```
+*/
+function createColumnTypes(config) {
 	const schema = config.schema;
 	function col(dataType, args) {
 		return createColumn(schema, dataType, args);
@@ -217,6 +238,43 @@ function t(config) {
 	};
 }
 //#endregion
+//#region src/init.ts
+/**
+* Create a lazy-initialized singleton factory.
+*
+* The factory function is called only once — on the first call to the returned
+* function. Subsequent calls return the same resolved promise. This avoids
+* module-level side effects: importing a model file won't trigger database
+* connection or schema initialization until the first explicit `await db()`.
+*
+* @example
+* ```ts
+* import { createClient } from "@libsql/client"
+* import { LibsqlDialect } from "@libsql/kysely-libsql"
+* import { createDb, createORM, defineModel, t } from "peta-orm"
+*
+* const User = defineModel("users", { columns: { ... } })
+*
+* async function setup() {
+*   const client = createClient({ url: "file:my-app.db" })
+*   await client.execute("CREATE TABLE IF NOT EXISTS users (...)") // schema init
+*   const orm = createORM({ dialect: new LibsqlDialect({ client }) })
+*   orm.registerAll(User)
+*   return orm
+* }
+*
+* export const db = createDb(setup)
+* // Usage: const orm = await db()
+* ```
+*/
+function createDb(factory) {
+	let promise = null;
+	return () => {
+		if (!promise) promise = factory();
+		return promise;
+	};
+}
+//#endregion
 //#region src/hooks/static.ts
 var static_exports = /* @__PURE__ */ __exportAll({
 	addStaticHook: () => addStaticHook,
@@ -1483,9 +1541,6 @@ function defineModel(table, config) {
 	def.registerSoftDeletes = (deletedAtCol) => {
 		registerSoftDeletesFor(def, deletedAtCol);
 	};
-	def.discover = async () => {
-		throw new Error("discover() not yet implemented in v2");
-	};
 	return def;
 }
 //#endregion
@@ -1895,9 +1950,14 @@ initRuntime({
 /**
 * Create an ORM instance — the central registry that wires Kysely to model definitions.
 * Replaces createPeta() from v0.x.
+*
+* Pass either `dialect` (to auto-create a Kysely instance) or `kysely` (to reuse one).
+* Passing a pre-existing Kysely instance avoids creating a second connection for
+* migration runners or other tools that already have their own Kysely.
 */
 function createORM(config) {
-	const kysely = new Kysely({ dialect: config.dialect });
+	if (!config.dialect && !config.kysely) throw new Error("createORM: provide either `dialect` (to create a Kysely instance) or `kysely` (to reuse one)");
+	const kysely = config.kysely ?? new Kysely({ dialect: config.dialect });
 	const modelMap = /* @__PURE__ */ new Map();
 	const orm = {
 		kysely,
@@ -1923,6 +1983,26 @@ function createORM(config) {
 		},
 		getModel(name) {
 			return modelMap.get(name);
+		},
+		async discover(pattern) {
+			const entries = await (await import("fast-glob")).glob(pattern, {
+				absolute: true,
+				onlyFiles: true
+			});
+			if (entries.length === 0) throw new Error(`discover: no files matched pattern "${pattern}"`);
+			const models = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const fp of entries) {
+				const mod = await import(pathToFileURL(fp).href);
+				for (const val of Object.values(mod)) if (val && typeof val === "object" && "columns" in val && "table" in val && typeof val.table === "string" && val.table.length > 0) {
+					const def = val;
+					if (!seen.has(def.table)) {
+						seen.add(def.table);
+						models.push(def);
+					}
+				}
+			}
+			return models;
 		}
 	};
 	if (config.models) for (const [_name, model] of Object.entries(config.models)) orm.register(model);
@@ -2601,4 +2681,65 @@ function defName(instance) {
 	return instance.constructor?.name ?? "model";
 }
 //#endregion
-export { Attribute, DatabaseError, ModelNotFoundError, ModelNotRegisteredError, RelationNotAllowedError, RelationNotFoundError, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, eager_exports as i, manyToMany, relation_exports as n, normalizeError, delete_exports as r, resolveMorphRelation, softDeletes, t, timestamps, ulid };
+//#region src/repo/index.ts
+/**
+* Create a repository — a composable set of chainable query methods.
+*
+* ```ts
+* const userRepo = createRepo(User, {
+*   queryMethods: {
+*     search(q, query: string) {
+*       return q.where('name', 'like', `%${query}%`)
+*     },
+*   },
+* })
+* const users = await userRepo.search('john').paginate(1, 20)
+* ```
+*/
+function createRepo(model, methods) {
+	const customMethods = /* @__PURE__ */ new Map();
+	if (methods.queryMethods) for (const [name, fn] of Object.entries(methods.queryMethods)) customMethods.set(name, fn);
+	/**
+	* Wrap a QueryBuilder so custom methods are available for chaining.
+	* Custom methods operate on the CURRENT QB (not a fresh one), so
+	* chaining carries forward previous conditions.
+	*/
+	function wrapQB(qb) {
+		return new Proxy(qb, { get(target, prop) {
+			if (typeof prop === "string") {
+				if (customMethods.has(prop)) {
+					const fn = customMethods.get(prop);
+					return (...args) => {
+						return wrapQB(fn(target, ...args));
+					};
+				}
+				if (methods.methods?.[prop]) return (...args) => methods.methods[prop](...args);
+			}
+			const val = target[prop];
+			if (typeof val === "function") return function(...args) {
+				const result = val.apply(target, args);
+				return result === target ? wrapQB(result) : result;
+			};
+			return val;
+		} });
+	}
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop === "string") {
+			if (customMethods.has(prop)) {
+				const fn = customMethods.get(prop);
+				return (...args) => {
+					return wrapQB(fn(model.query(), ...args));
+				};
+			}
+			if (methods.methods?.[prop]) return (...args) => methods.methods[prop](...args);
+		}
+		const qb = model.query();
+		const val = qb[prop];
+		if (typeof val === "function") return (...args) => {
+			return wrapQB(val.apply(qb, args));
+		};
+		return val;
+	} });
+}
+//#endregion
+export { Attribute, DatabaseError, ModelNotFoundError, ModelNotRegisteredError, RelationNotAllowedError, RelationNotFoundError, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createColumnTypes, createDb, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, createRepo, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, eager_exports as i, manyToMany, relation_exports as n, normalizeError, delete_exports as r, resolveMorphRelation, softDeletes, t, timestamps, ulid };

package/package.json

@@ -2,31 +2,23 @@
   "name": "peta-orm",
   "type": "module",
   "private": false,
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "ORM for Bun, built on Kysely",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zfadhli/peta-stack.git"
   },
-  "module": "src/index.ts",
+  "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "types": "./dist/index.d.mts"
-    },
-    "./migrator": {
-      "import": "./dist/migrations/index.mjs",
-      "types": "./dist/migrations/index.d.mts"
     }
   },
-  "bin": {
-    "peta": "./bin/peta"
-  },
   "files": [
-    "bin/",
     "dist/",
     "README.md",
     "LICENSE"
@@ -34,6 +26,7 @@
   "dependencies": {
     "arktype": "^2.2.0",
     "cac": "^7.0.0",
+    "fast-glob": "^3.3.3",
     "ora": "^9.4.0",
     "ulid": "^3.0.2"
   },
@@ -63,6 +56,6 @@
     "build": "tsdown",
     "lint": "bunx biome check src test examples",
     "lint:fix": "bunx biome check --write --unsafe src test examples",
-    "prepublish": "bun run build"
+    "prepublishOnly": "bun run build"
   }
 }

package/bin/peta

@@ -1,3 +0,0 @@
-#!/usr/bin/env bun
-import { run } from "../dist/migrations/cli.mjs"
-await run()