@bunyad/orm 0.1.0-alpha.0

package/dist/scopes.d.ts

@@ -0,0 +1,36 @@
+import type { ModelQuery } from "./model.js";
+export type GlobalScopeCallback = (query: ModelQuery) => void;
+type ModelClassLike = abstract new (...args: never[]) => unknown;
+/** Register a named global scope on a model class. */
+export declare function addGlobalScope(model: ModelClassLike, name: string, scope: GlobalScopeCallback): void;
+/** Remove a named global scope from a model class. */
+export declare function removeGlobalScope(model: ModelClassLike, name: string): void;
+/** All registered global scopes for a model class. */
+export declare function getGlobalScopes(model: ModelClassLike): Map<string, GlobalScopeCallback>;
+export declare function hasGlobalScopes(model: ModelClassLike): boolean;
+/** Clear scopes (tests). */
+export declare function clearGlobalScopes(model?: ModelClassLike): void;
+type CallStaticModel = {
+    newQuery(): ModelQuery;
+};
+/**
+ * Safe ModelQuery terminals forwarded by Model `__callStatic`
+ * (`Model.get()` → `Model.query().get()`).
+ *
+ * Allowlist only — avoid constructors, `then`, starters already owned as
+ * Model statics, and arbitrary junk. Own Model / subclass statics always win
+ * over this Proxy. Local `scopeFoo` still wins when present.
+ *
+ * @see https://laravel.com/docs/eloquent#retrieving-models
+ */
+export declare const MODEL_STATIC_BUILDER_TERMINALS: ReadonlySet<string>;
+/**
+ * Laravel `__callStatic`:
+ * - Local scopes: `Model.foo()` → `Model.query().foo()` when `scopeFoo` exists
+ * - Builder terminals: `Model.get()` / `pluck` / `count` / … → `Model.query()[method](…)`
+ *
+ * Installed as Model's [[Prototype]] so missing static lookups on subclasses
+ * (e.g. `Shop.active`, `User.get`) reach this trap before `Function.prototype`.
+ */
+export declare function installLocalScopeCallStatic(ModelCtor: CallStaticModel): void;
+export {};

package/dist/scopes.js

@@ -0,0 +1,128 @@
+const registry = new WeakMap();
+function scopesFor(model) {
+    let map = registry.get(model);
+    if (!map) {
+        map = new Map();
+        registry.set(model, map);
+    }
+    return map;
+}
+/** Register a named global scope on a model class. */
+export function addGlobalScope(model, name, scope) {
+    scopesFor(model).set(name, scope);
+}
+/** Remove a named global scope from a model class. */
+export function removeGlobalScope(model, name) {
+    scopesFor(model).delete(name);
+}
+const EMPTY_SCOPES = new Map();
+/** All registered global scopes for a model class. */
+export function getGlobalScopes(model) {
+    return registry.get(model) ?? EMPTY_SCOPES;
+}
+export function hasGlobalScopes(model) {
+    const map = registry.get(model);
+    return map != null && map.size > 0;
+}
+/** Clear scopes (tests). */
+export function clearGlobalScopes(model) {
+    if (model) {
+        registry.delete(model);
+        return;
+    }
+}
+/**
+ * Safe ModelQuery terminals forwarded by Model `__callStatic`
+ * (`Model.get()` → `Model.query().get()`).
+ *
+ * Allowlist only — avoid constructors, `then`, starters already owned as
+ * Model statics, and arbitrary junk. Own Model / subclass statics always win
+ * over this Proxy. Local `scopeFoo` still wins when present.
+ *
+ * @see https://laravel.com/docs/eloquent#retrieving-models
+ */
+export const MODEL_STATIC_BUILDER_TERMINALS = new Set([
+    "get",
+    "pluck",
+    "value",
+    "count",
+    "sum",
+    "avg",
+    "min",
+    "max",
+    "exists",
+    "doesntExist",
+    "first",
+    "firstOrFail",
+    "sole",
+    "valueOrFail",
+    "soleValue",
+    "paginate",
+    "simplePaginate",
+    "cursorPaginate",
+    "getSync",
+    "firstSync",
+    "toSql",
+    "toRawSql",
+    "getBindings",
+]);
+/**
+ * Laravel `__callStatic`:
+ * - Local scopes: `Model.foo()` → `Model.query().foo()` when `scopeFoo` exists
+ * - Builder terminals: `Model.get()` / `pluck` / `count` / … → `Model.query()[method](…)`
+ *
+ * Installed as Model's [[Prototype]] so missing static lookups on subclasses
+ * (e.g. `Shop.active`, `User.get`) reach this trap before `Function.prototype`.
+ */
+export function installLocalScopeCallStatic(ModelCtor) {
+    const parent = Object.getPrototypeOf(ModelCtor);
+    if (parent &&
+        parent
+            .__bunyadLocalScopeCallStatic) {
+        return;
+    }
+    const trap = new Proxy(parent, {
+        get(target, prop, receiver) {
+            if (typeof prop === "symbol") {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (typeof prop === "string" &&
+                prop.length > 0 &&
+                !prop.startsWith("scope") &&
+                prop !== "prototype" &&
+                prop !== "name" &&
+                prop !== "length") {
+                const scopeName = `scope${prop.charAt(0).toUpperCase()}${prop.slice(1)}`;
+                const scopeFn = receiver[scopeName];
+                if (typeof scopeFn === "function") {
+                    return (...args) => {
+                        const q = receiver.newQuery();
+                        const onQuery = q[prop];
+                        if (typeof onQuery === "function") {
+                            return onQuery.apply(q, args);
+                        }
+                        scopeFn.call(receiver, q, ...args);
+                        return q;
+                    };
+                }
+                if (MODEL_STATIC_BUILDER_TERMINALS.has(prop)) {
+                    return (...args) => {
+                        const q = receiver.newQuery();
+                        const fn = q[prop];
+                        if (typeof fn !== "function") {
+                            throw new TypeError(`${receiver.name ?? "Model"}.${prop} is not available on the query builder.`);
+                        }
+                        return fn.apply(q, args);
+                    };
+                }
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    Object.defineProperty(trap, "__bunyadLocalScopeCallStatic", {
+        value: true,
+        enumerable: false,
+        configurable: false,
+    });
+    Object.setPrototypeOf(ModelCtor, trap);
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@bunyad/orm",
+  "version": "0.1.0-alpha.0",
+  "description": "Active-record ORM for Bunyad: models, relations, casts, scopes, events, factories.",
+  "license": "MIT",
+  "author": "Shah Khalid",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bunyadjs/framework.git",
+    "directory": "packages/orm"
+  },
+  "homepage": "https://github.com/bunyadjs/framework#readme",
+  "bugs": {
+    "url": "https://github.com/bunyadjs/framework/issues"
+  },
+  "keywords": [
+    "bunyad",
+    "bun",
+    "typescript",
+    "orm",
+    "active-record"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@bunyad/common": "^0.1.0-alpha.0",
+    "@bunyad/database": "^0.1.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test",
+    "build": "bun ../../scripts/build-package.ts ."
+  }
+}