@hazejs/orm 0.0.0-stage → 0.1.2

package/dist/record-DtkUCWRf.mjs

@@ -0,0 +1,335 @@
+import { ConflictException, NotFoundException } from "@hazejs/core";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getTableColumns } from "drizzle-orm";
+// src/errors.ts
+/** findOrFail() 未找到数据，渲染为 404 */
+var ModelNotFoundException = class extends NotFoundException {
+	model;
+	constructor(model, key) {
+		super(key === void 0 ? `${model} 不存在` : `${model} ${String(key)} 不存在`);
+		this.model = model;
+	}
+};
+var DatabaseError = class extends Error {
+	name = "DatabaseError";
+};
+/** 违反唯一约束（重复数据），渲染为 409 */
+var UniqueConstraintException = class extends ConflictException {
+	constructor(cause) {
+		super("数据已存在（违反唯一约束）", { cause });
+	}
+};
+/** 把各数据库的唯一约束错误统一转换为 UniqueConstraintException，其余原样返回 */
+function translateDatabaseError(error) {
+	for (let current = error, depth = 0; current && depth < 5; current = current.cause, depth++) {
+		const code = String(current.code ?? "");
+		const message = String(current.message ?? "");
+		if (code === "11000" || current.code === 11e3 || code === "23505" || code === "ER_DUP_ENTRY" || current.errno === 1062 || code.startsWith("SQLITE_CONSTRAINT_UNIQUE") || code === "SQLITE_CONSTRAINT_PRIMARYKEY" || /UNIQUE constraint failed/.test(message)) return new UniqueConstraintException(error);
+	}
+	return error;
+}
+// src/context.ts
+let manager;
+/** 由 databaseProvider() 在应用启动时设置；脚本 / 测试中可直接调用 */
+function setDatabaseManager(value) {
+	manager = value;
+}
+function useDatabaseManager() {
+	if (!manager) throw new DatabaseError("Database is not configured. Add databaseProvider() in app/provider and create config/database.ts");
+	return manager;
+}
+/** 事务上下文：连接名 → 事务内的 drizzle 实例 */
+const transactions = new AsyncLocalStorage();
+async function resolveSession(connection) {
+	const resolved = await useDatabaseManager().connection(connection);
+	if (resolved.dialect === "mongodb") throw new DatabaseError(`Connection "${resolved.name}" is MongoDB; use Mongo / MongoModel from @hazejs/orm/mongo`);
+	return {
+		name: resolved.name,
+		driver: resolved.driver,
+		dialect: resolved.dialect,
+		db: transactions.getStore()?.get(resolved.name) ?? resolved.db
+	};
+}
+/**
+* 在事务中执行；回调内通过 Db / Model 发起的查询自动加入该事务（隐式传播），
+* 嵌套调用使用保存点。回调抛错时回滚。
+*/
+async function transaction(callback, connection) {
+	const session = await resolveSession(connection);
+	if (session.driver === "d1") throw new DatabaseError(`Connection "${session.name}" is Cloudflare D1, which does not support interactive transactions; use (await Db.drizzle()).batch([...]) for atomic writes`);
+	const store = transactions.getStore();
+	return session.db.transaction((tx) => transactions.run(new Map(store).set(session.name, tx), () => callback(tx)));
+}
+// src/utils.ts
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+const primaryKeys = /* @__PURE__ */ new WeakMap();
+/** 单列主键的属性名（复合主键返回 undefined） */
+function primaryKeyOf(table) {
+	if (!primaryKeys.has(table)) {
+		const keys = Object.entries(getTableColumns(table)).filter(([, column]) => column.primary).map(([key]) => key);
+		primaryKeys.set(table, keys.length === 1 ? keys[0] : void 0);
+	}
+	return primaryKeys.get(table);
+}
+/** 按列的数据类型生成“当前时间”：Date / ISO 字符串 / 毫秒数 */
+function nowFor(column) {
+	const now = /* @__PURE__ */ new Date();
+	switch (column.dataType) {
+		case "string": return now.toISOString();
+		case "number": return now.getTime();
+		default: return now;
+	}
+}
+/** 各驱动的“影响行数”字段不同 */
+function affectedRows(result) {
+	const value = result?.rowsAffected ?? result?.affectedRows ?? result?.[0]?.affectedRows ?? result?.meta?.changes ?? result?.count ?? result?.rowCount ?? 0;
+	return Number(value);
+}
+function pascalCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => (char ?? "").toUpperCase()).replace(/^./, (char) => char.toUpperCase());
+}
+// src/model/relations.ts
+function queryOf(related) {
+	return related.query();
+}
+/**
+* 关联关系。可直接 await 获取结果，也可继续构造查询：
+*
+* ```ts
+* const posts = await user.posts()
+* const recent = await user.posts().query().order('id', 'desc').limit(5).select()
+* ```
+*/
+var Relation = class {
+	parent;
+	related;
+	constructor(parent, related) {
+		this.parent = parent;
+		this.related = related;
+	}
+	then(onFulfilled, onRejected) {
+		return this.get().then(onFulfilled, onRejected);
+	}
+};
+var HasOneOrMany = class extends Relation {
+	foreignKey;
+	localKey;
+	constructor(parent, related, foreignKey, localKey) {
+		super(parent, related);
+		this.foreignKey = foreignKey;
+		this.localKey = localKey;
+	}
+	query() {
+		return queryOf(this.related).where(this.foreignKey, this.parent.getRaw(this.localKey));
+	}
+	async loadFor(parents, nested) {
+		const keys = unique(parents.map((parent) => parent.getRaw(this.localKey)));
+		const groups = /* @__PURE__ */ new Map();
+		if (!keys.length) return groups;
+		const children = await queryOf(this.related).whereIn(this.foreignKey, keys).with(...nested).select();
+		for (const child of children) {
+			const key = keyOf(child.getRaw(this.foreignKey));
+			groups.set(key, [...groups.get(key) ?? [], child]);
+		}
+		return groups;
+	}
+};
+var HasMany = class extends HasOneOrMany {
+	get() {
+		return this.query().select();
+	}
+	async eagerLoad(parents, name, nested) {
+		const groups = await this.loadFor(parents, nested);
+		for (const parent of parents) parent.setRelation(name, groups.get(keyOf(parent.getRaw(this.localKey))) ?? []);
+	}
+};
+var HasOne = class extends HasOneOrMany {
+	async get() {
+		return await this.query().find() ?? null;
+	}
+	async eagerLoad(parents, name, nested) {
+		const groups = await this.loadFor(parents, nested);
+		for (const parent of parents) parent.setRelation(name, groups.get(keyOf(parent.getRaw(this.localKey)))?.[0] ?? null);
+	}
+};
+var BelongsTo = class extends Relation {
+	foreignKey;
+	ownerKey;
+	constructor(parent, related, foreignKey, ownerKey) {
+		super(parent, related);
+		this.foreignKey = foreignKey;
+		this.ownerKey = ownerKey;
+	}
+	query() {
+		return queryOf(this.related).where(this.ownerKey, this.parent.getRaw(this.foreignKey));
+	}
+	async get() {
+		if (this.parent.getRaw(this.foreignKey) == null) return null;
+		return await this.query().find() ?? null;
+	}
+	async eagerLoad(parents, name, nested) {
+		const keys = unique(parents.map((parent) => parent.getRaw(this.foreignKey)));
+		const owners = keys.length ? await queryOf(this.related).whereIn(this.ownerKey, keys).with(...nested).select() : [];
+		const byKey = new Map(owners.map((owner) => [keyOf(owner.getRaw(this.ownerKey)), owner]));
+		for (const parent of parents) parent.setRelation(name, byKey.get(keyOf(parent.getRaw(this.foreignKey))) ?? null);
+	}
+};
+/** 预加载：`['posts', 'posts.comments', 'profile']` 按第一段分组，其余作为嵌套关联 */
+async function loadRelations(records, names) {
+	if (!records.length) return;
+	const tree = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const [head, ...rest] = name.split(".");
+		const nested = tree.get(head) ?? [];
+		if (rest.length) nested.push(rest.join("."));
+		tree.set(head, nested);
+	}
+	for (const [name, nested] of tree) {
+		const factory = records[0][name];
+		if (typeof factory !== "function") throw new TypeError(`Relation "${name}" is not defined on ${records[0].constructor.name}`);
+		const relation = factory.call(records[0]);
+		if (!(relation instanceof Relation)) throw new TypeError(`${records[0].constructor.name}.${name}() must return this.hasMany() / this.hasOne() / this.belongsTo()`);
+		await relation.eagerLoad(records, name, nested);
+	}
+}
+function defaultKey(record) {
+	const key = record.primaryKeyName();
+	if (!key) throw new Error(`${record.name} has no single-column primary key; pass the key explicitly`);
+	return key;
+}
+/** 关联键的比较值：ObjectId 等对象按字符串比较 */
+function keyOf(value) {
+	if (value && typeof value === "object" && typeof value.toHexString === "function") return value.toHexString();
+	return value;
+}
+function unique(values) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const value of values) if (value !== null && value !== void 0 && !seen.has(keyOf(value))) seen.set(keyOf(value), value);
+	return [...seen.values()];
+}
+// src/model/record.ts
+/**
+* SQL 模型（Model）与 MongoDB 模型（MongoModel）共用的基类：
+* 属性与脏检查、访问器 / 修改器、关联、序列化与事件。
+*
+* 内部状态使用 `$` 前缀的受保护字段，避免与真实字段名冲突。
+*/
+var ActiveRecord = class {
+	/** 序列化时隐藏的字段 */
+	static hidden = [];
+	/** 序列化时追加的虚拟字段（需定义 getXxxAttr） */
+	static append = [];
+	$attributes = {};
+	$original = {};
+	$relations = {};
+	$exists = false;
+	/** 主键字段名（子类实现） */
+	static primaryKeyName() {}
+	/** 由数据库行 / 文档构造已存在的记录 */
+	static hydrate(row) {
+		const record = new this();
+		record.$attributes = { ...row };
+		record.$original = { ...row };
+		record.$exists = true;
+		return record;
+	}
+	get exists() {
+		return this.$exists;
+	}
+	/** 主键值 */
+	getKey() {
+		const key = this.constructor.primaryKeyName();
+		return key ? this.$attributes[key] : void 0;
+	}
+	/** 读取属性（经过 getXxxAttr 访问器） */
+	getAttr(key) {
+		const accessor = this[`get${pascalCase(key)}Attr`];
+		const value = this.$attributes[key];
+		return typeof accessor === "function" ? accessor.call(this, value, this.$attributes) : value;
+	}
+	/** 写入属性（经过 setXxxAttr 修改器） */
+	setAttr(key, value) {
+		const mutator = this[`set${pascalCase(key)}Attr`];
+		this.$attributes[key] = typeof mutator === "function" ? mutator.call(this, value, this.$attributes) : value;
+		return this;
+	}
+	/** 原始属性（不经过访问器） */
+	getRaw(key) {
+		return this.$attributes[key];
+	}
+	/** 批量赋值（SQL 模型忽略表中不存在的列） */
+	fill(data) {
+		for (const [key, value] of Object.entries(data)) if (this.acceptsAttribute(key)) this.setAttr(key, value);
+		return this;
+	}
+	isDirty(key) {
+		const dirty = this.getDirty();
+		return key ? key in dirty : Object.keys(dirty).length > 0;
+	}
+	/** 自上次同步以来修改过的字段 */
+	getDirty() {
+		const dirty = {};
+		for (const [key, value] of Object.entries(this.$attributes)) if (!this.$exists || !sameValue(value, this.$original[key])) dirty[key] = value;
+		return dirty;
+	}
+	getOriginal(key) {
+		return key ? this.$original[key] : { ...this.$original };
+	}
+	/** 加载关联（可嵌套）：`await user.load('posts.comments')` */
+	async load(...relations) {
+		await loadRelations([this], relations);
+		return this;
+	}
+	/** 已加载的关联结果 */
+	getRelation(name) {
+		return this.$relations[name];
+	}
+	setRelation(name, value) {
+		this.$relations[name] = value;
+		return this;
+	}
+	hasMany(related, foreignKey, localKey) {
+		return new HasMany(this, related, foreignKey, localKey ?? defaultKey(this.constructor));
+	}
+	hasOne(related, foreignKey, localKey) {
+		return new HasOne(this, related, foreignKey, localKey ?? defaultKey(this.constructor));
+	}
+	belongsTo(related, foreignKey, ownerKey) {
+		return new BelongsTo(this, related, foreignKey, ownerKey ?? defaultKey(related));
+	}
+	/** 序列化：应用访问器、隐藏字段、追加字段与已加载的关联 */
+	toJSON() {
+		const record = this.constructor;
+		const hidden = new Set(record.hidden);
+		const result = {};
+		for (const key of Object.keys(this.$attributes)) if (!hidden.has(key)) result[key] = this.getAttr(key);
+		for (const key of record.append) result[key] = this.getAttr(key);
+		for (const [key, value] of Object.entries(this.$relations)) if (!hidden.has(key)) result[key] = Array.isArray(value) ? value.map(serialize) : serialize(value);
+		return result;
+	}
+	/** 是否接受批量赋值的字段 */
+	acceptsAttribute(_key) {
+		return true;
+	}
+	async runHook(name) {
+		const hook = this[name];
+		if (typeof hook === "function") await hook.call(this);
+	}
+	/** 写入成功后同步原始值 */
+	syncOriginal() {
+		this.$original = { ...this.$attributes };
+	}
+};
+function serialize(value) {
+	return value instanceof ActiveRecord ? value.toJSON() : value;
+}
+function sameValue(a, b) {
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a && b && typeof a === "object" && typeof a.equals === "function") return a.equals(b);
+	return Object.is(a, b);
+}
+export { DatabaseError as _, Relation as a, translateDatabaseError as b, affectedRows as c, pascalCase as d, primaryKeyOf as f, useDatabaseManager as g, transaction as h, HasOne as i, isPlainObject as l, setDatabaseManager as m, BelongsTo as n, defaultKey as o, resolveSession as p, HasMany as r, loadRelations as s, ActiveRecord as t, nowFor as u, ModelNotFoundException as v, UniqueConstraintException as y };

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@hazejs/orm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.1.2",
+  "description": "Models, query builder and migrations for hazejs on top of drizzle (MySQL, PostgreSQL, SQLite, Turso, D1, MongoDB)",
+  "license": "MIT",
+  "homepage": "https://github.com/penna-org/haze/tree/main/packages/orm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/penna-org/haze.git",
+    "directory": "packages/orm"
+  },
+  "bugs": {
+    "url": "https://github.com/penna-org/haze/issues"
+  },
+  "keywords": [
+    "hazejs",
+    "haze",
+    "nodejs",
+    "typescript",
+    "orm",
+    "drizzle",
+    "mysql",
+    "postgresql",
+    "sqlite",
+    "turso",
+    "d1",
+    "mongodb",
+    "active-record"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./mongo": {
+      "types": "./dist/mongo/index.d.mts",
+      "default": "./dist/mongo/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "peerDependencies": {
+    "@electric-sql/pglite": "^0.5.0",
+    "@libsql/client": "^0.18.0",
+    "drizzle-orm": "^0.45.0",
+    "mongodb": "^7.0.0",
+    "mysql2": "^3.0.0",
+    "postgres": "^3.4.0",
+    "@hazejs/core": "^0.1.2"
+  },
+  "peerDependenciesMeta": {
+    "@electric-sql/pglite": {
+      "optional": true
+    },
+    "@libsql/client": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "postgres": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.5.12",
+    "@libsql/client": "^0.18.0",
+    "drizzle-orm": "^0.45.4",
+    "miniflare": "^4.20260730.0",
+    "mongodb": "^7.7.0",
+    "mongodb-memory-server-core": "^11.3.0",
+    "mysql2": "^3.24.6",
+    "postgres": "^3.4.9",
+    "@hazejs/core": "0.1.2"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
 }