@zenstackhq/better-auth 3.5.6 → 3.6.0

package/dist/index.cjs

@@ -1,721 +1,554 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  zenstackAdapter: () => zenstackAdapter
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/adapter.ts
-var import_error = require("@better-auth/core/error");
-var import_adapters = require("better-auth/adapters");
-
-// src/schema-generator.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_language = require("@zenstackhq/language");
-var import_ast = require("@zenstackhq/language/ast");
-var import_utils = require("@zenstackhq/language/utils");
-var import_node_fs = __toESM(require("fs"), 1);
-var import_ts_pattern = require("ts-pattern");
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _better_auth_core_error = require("@better-auth/core/error");
+let better_auth_adapters = require("better-auth/adapters");
+let _zenstackhq_common_helpers = require("@zenstackhq/common-helpers");
+let _zenstackhq_language = require("@zenstackhq/language");
+let _zenstackhq_language_ast = require("@zenstackhq/language/ast");
+let _zenstackhq_language_utils = require("@zenstackhq/language/utils");
+require("better-auth");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let ts_pattern = require("ts-pattern");
+//#region src/schema-generator.ts
 async function generateSchema(file, tables, config, options) {
-  let filePath = file;
-  if (!filePath) {
-    if (import_node_fs.default.existsSync("./schema.zmodel")) {
-      filePath = "./schema.zmodel";
-    } else {
-      filePath = "./zenstack/schema.zmodel";
-    }
-  }
-  const schemaExists = import_node_fs.default.existsSync(filePath);
-  const schema = await updateSchema(filePath, tables, config, options);
-  return {
-    code: schema ?? "",
-    path: filePath,
-    overwrite: schemaExists && !!schema
-  };
+	let filePath = file;
+	if (!filePath) if (node_fs.default.existsSync("./schema.zmodel")) filePath = "./schema.zmodel";
+	else filePath = "./zenstack/schema.zmodel";
+	const schemaExists = node_fs.default.existsSync(filePath);
+	const schema = await updateSchema(filePath, tables, config, options);
+	return {
+		code: schema ?? "",
+		path: filePath,
+		overwrite: schemaExists && !!schema
+	};
 }
-__name(generateSchema, "generateSchema");
 async function updateSchema(schemaPath, tables, config, options) {
-  let zmodel;
-  if (import_node_fs.default.existsSync(schemaPath)) {
-    const loadResult = await (0, import_language.loadDocument)(schemaPath);
-    if (!loadResult.success) {
-      throw new Error(`Failed to load existing schema at ${schemaPath}: ${loadResult.errors.join(", ")}`);
-    }
-    zmodel = loadResult.model;
-  } else {
-    zmodel = initializeZmodel(config);
-  }
-  const toManyRelations = /* @__PURE__ */ new Map();
-  for (const [tableName, table] of Object.entries(tables)) {
-    const fields = tables[tableName]?.fields;
-    for (const field in fields) {
-      const attr = fields[field];
-      if (attr.references) {
-        const referencedOriginalModel = attr.references.model;
-        const referencedCustomModel = tables[referencedOriginalModel]?.modelName || referencedOriginalModel;
-        const referencedModelNameCap = (0, import_common_helpers.upperCaseFirst)(referencedCustomModel);
-        if (!toManyRelations.has(referencedModelNameCap)) {
-          toManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
-        }
-        const currentCustomModel = table.modelName ?? tableName;
-        const currentModelNameCap = (0, import_common_helpers.upperCaseFirst)(currentCustomModel);
-        toManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
-      }
-    }
-  }
-  let changed = false;
-  for (const [name, table] of Object.entries(tables)) {
-    const c = addOrUpdateModel(name, table, zmodel, tables, toManyRelations, !!options.advanced?.database?.useNumberId);
-    changed = changed || c;
-  }
-  if (!changed) {
-    return void 0;
-  }
-  const generator = new import_language.ZModelCodeGenerator();
-  let content = generator.generate(zmodel);
-  try {
-    content = await (0, import_language.formatDocument)(content);
-  } catch {
-  }
-  return content;
+	let zmodel;
+	if (node_fs.default.existsSync(schemaPath)) {
+		const loadResult = await (0, _zenstackhq_language.loadDocument)(schemaPath);
+		if (!loadResult.success) throw new Error(`Failed to load existing schema at ${schemaPath}: ${loadResult.errors.join(", ")}`);
+		zmodel = loadResult.model;
+	} else zmodel = initializeZmodel(config);
+	const toManyRelations = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(tables)) {
+		const fields = tables[tableName]?.fields;
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.references) {
+				const referencedOriginalModel = attr.references.model;
+				const referencedModelNameCap = (0, _zenstackhq_common_helpers.upperCaseFirst)(tables[referencedOriginalModel]?.modelName || referencedOriginalModel);
+				if (!toManyRelations.has(referencedModelNameCap)) toManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
+				const currentModelNameCap = (0, _zenstackhq_common_helpers.upperCaseFirst)(table.modelName ?? tableName);
+				toManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
+			}
+		}
+	}
+	let changed = false;
+	for (const [name, table] of Object.entries(tables)) {
+		const c = addOrUpdateModel(name, table, zmodel, tables, toManyRelations, !!options.advanced?.database?.useNumberId);
+		changed = changed || c;
+	}
+	if (!changed) return;
+	let content = new _zenstackhq_language.ZModelCodeGenerator().generate(zmodel);
+	try {
+		content = await (0, _zenstackhq_language.formatDocument)(content);
+	} catch {}
+	return content;
 }
-__name(updateSchema, "updateSchema");
 function addDefaultNow(df) {
-  const nowArg = {
-    $type: "AttributeArg"
-  };
-  const nowExpr = {
-    $type: "InvocationExpr",
-    function: {
-      $refText: "now"
-    },
-    args: [],
-    $container: nowArg
-  };
-  nowArg.value = nowExpr;
-  addFieldAttribute(df, "@default", [
-    nowArg
-  ]);
+	const nowArg = { $type: "AttributeArg" };
+	nowArg.value = {
+		$type: "InvocationExpr",
+		function: { $refText: "now" },
+		args: [],
+		$container: nowArg
+	};
+	addFieldAttribute(df, "@default", [nowArg]);
 }
-__name(addDefaultNow, "addDefaultNow");
 function createDataModel(modelName, zmodel, numericId) {
-  const dataModel = {
-    $type: "DataModel",
-    name: modelName,
-    fields: [],
-    attributes: [],
-    mixins: [],
-    comments: [],
-    isView: false,
-    $container: zmodel
-  };
-  let idField;
-  if (numericId) {
-    idField = addModelField(dataModel, "id", "Int", false, false);
-  } else {
-    idField = addModelField(dataModel, "id", "String", false, false);
-  }
-  addFieldAttribute(idField, "@id");
-  return dataModel;
+	const dataModel = {
+		$type: "DataModel",
+		name: modelName,
+		fields: [],
+		attributes: [],
+		mixins: [],
+		comments: [],
+		isView: false,
+		$container: zmodel
+	};
+	let idField;
+	if (numericId) idField = addModelField(dataModel, "id", "Int", false, false);
+	else idField = addModelField(dataModel, "id", "String", false, false);
+	addFieldAttribute(idField, "@id");
+	return dataModel;
 }
-__name(createDataModel, "createDataModel");
 function addModelField(dataModel, fieldName, fieldType, array, optional) {
-  const field = {
-    $type: "DataField",
-    name: fieldName,
-    attributes: [],
-    comments: [],
-    $container: dataModel
-  };
-  field.type = {
-    $type: "DataFieldType",
-    type: fieldType,
-    array,
-    optional,
-    $container: field
-  };
-  dataModel.fields.push(field);
-  return field;
+	const field = {
+		$type: "DataField",
+		name: fieldName,
+		attributes: [],
+		comments: [],
+		$container: dataModel
+	};
+	field.type = {
+		$type: "DataFieldType",
+		type: fieldType,
+		array,
+		optional,
+		$container: field
+	};
+	dataModel.fields.push(field);
+	return field;
 }
-__name(addModelField, "addModelField");
 function initializeZmodel(config) {
-  const zmodel = {
-    $type: "Model",
-    declarations: [],
-    imports: []
-  };
-  const ds = {
-    $type: "DataSource",
-    name: "db",
-    fields: [],
-    $container: zmodel
-  };
-  zmodel.declarations.push(ds);
-  const providerField = {
-    $type: "ConfigField",
-    name: "provider",
-    $container: ds
-  };
-  providerField.value = {
-    $type: "StringLiteral",
-    value: config.provider,
-    $container: providerField
-  };
-  const urlField = {
-    $type: "ConfigField",
-    name: "url",
-    $container: ds
-  };
-  const envCall = {
-    $type: "InvocationExpr",
-    function: {
-      $refText: "env"
-    },
-    args: [],
-    $container: urlField
-  };
-  const dbUrlArg = {
-    $type: "Argument"
-  };
-  dbUrlArg.value = {
-    $type: "StringLiteral",
-    value: "DATABASE_URL",
-    $container: dbUrlArg
-  };
-  envCall.args = [
-    dbUrlArg
-  ];
-  urlField.value = config.provider === "sqlite" ? {
-    $type: "StringLiteral",
-    value: "file:./dev.db",
-    $container: urlField
-  } : envCall;
-  ds.fields.push(providerField);
-  ds.fields.push(urlField);
-  return zmodel;
+	const zmodel = {
+		$type: "Model",
+		declarations: [],
+		imports: []
+	};
+	const ds = {
+		$type: "DataSource",
+		name: "db",
+		fields: [],
+		$container: zmodel
+	};
+	zmodel.declarations.push(ds);
+	const providerField = {
+		$type: "ConfigField",
+		name: "provider",
+		$container: ds
+	};
+	providerField.value = {
+		$type: "StringLiteral",
+		value: config.provider,
+		$container: providerField
+	};
+	const urlField = {
+		$type: "ConfigField",
+		name: "url",
+		$container: ds
+	};
+	const envCall = {
+		$type: "InvocationExpr",
+		function: { $refText: "env" },
+		args: [],
+		$container: urlField
+	};
+	const dbUrlArg = { $type: "Argument" };
+	dbUrlArg.value = {
+		$type: "StringLiteral",
+		value: "DATABASE_URL",
+		$container: dbUrlArg
+	};
+	envCall.args = [dbUrlArg];
+	urlField.value = config.provider === "sqlite" ? {
+		$type: "StringLiteral",
+		value: "file:./dev.db",
+		$container: urlField
+	} : envCall;
+	ds.fields.push(providerField);
+	ds.fields.push(urlField);
+	return zmodel;
 }
-__name(initializeZmodel, "initializeZmodel");
 function getMappedFieldType({ bigint, type }) {
-  return (0, import_ts_pattern.match)(type).with("string", () => ({
-    type: "String"
-  })).with("number", () => bigint ? {
-    type: "BigInt"
-  } : {
-    type: "Int"
-  }).with("boolean", () => ({
-    type: "Boolean"
-  })).with("date", () => ({
-    type: "DateTime"
-  })).with("json", () => ({
-    type: "Json"
-  })).with("string[]", () => ({
-    type: "String",
-    array: true
-  })).with("number[]", () => ({
-    type: "Int",
-    array: true
-  })).when((v) => Array.isArray(v) && v.every((e) => typeof e === "string"), () => {
-    return {
-      type: "String"
-    };
-  }).otherwise(() => {
-    throw new Error(`Unsupported field type: ${type}`);
-  });
+	return (0, ts_pattern.match)(type).with("string", () => ({ type: "String" })).with("number", () => bigint ? { type: "BigInt" } : { type: "Int" }).with("boolean", () => ({ type: "Boolean" })).with("date", () => ({ type: "DateTime" })).with("json", () => ({ type: "Json" })).with("string[]", () => ({
+		type: "String",
+		array: true
+	})).with("number[]", () => ({
+		type: "Int",
+		array: true
+	})).when((v) => Array.isArray(v) && v.every((e) => typeof e === "string"), () => {
+		return { type: "String" };
+	}).otherwise(() => {
+		throw new Error(`Unsupported field type: ${type}`);
+	});
 }
-__name(getMappedFieldType, "getMappedFieldType");
 function addOrUpdateModel(tableName, table, zmodel, tables, toManyRelations, numericId) {
-  let changed = false;
-  const customModelName = tables[tableName]?.modelName ?? tableName;
-  const modelName = (0, import_common_helpers.upperCaseFirst)(customModelName);
-  let dataModel = zmodel.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.name === modelName);
-  if (!dataModel) {
-    changed = true;
-    dataModel = createDataModel(modelName, zmodel, numericId);
-    zmodel.declarations.push(dataModel);
-  }
-  if (modelName !== tableName && !(0, import_utils.hasAttribute)(dataModel, "@@map")) {
-    addModelAttribute(dataModel, "@@map", [
-      createStringAttributeArg(tableName)
-    ]);
-  }
-  for (const [fName, field] of Object.entries(table.fields)) {
-    const fieldName = field.fieldName ?? fName;
-    if (dataModel.fields.some((f) => f.name === fieldName)) {
-      continue;
-    }
-    changed = true;
-    if (!field.references) {
-      const { array, type } = getMappedFieldType(field);
-      const df = {
-        $type: "DataField",
-        name: fieldName,
-        attributes: [],
-        comments: [],
-        $container: dataModel
-      };
-      df.type = {
-        $type: "DataFieldType",
-        type,
-        array: !!array,
-        optional: !field.required,
-        $container: df
-      };
-      dataModel.fields.push(df);
-      if (fieldName === "id") {
-        addFieldAttribute(df, "@id");
-      }
-      if (field.unique) {
-        addFieldAttribute(df, "@unique");
-      }
-      if (field.defaultValue !== void 0) {
-        if (fieldName === "createdAt") {
-          addDefaultNow(df);
-        } else if (typeof field.defaultValue === "boolean") {
-          addFieldAttribute(df, "@default", [
-            createBooleanAttributeArg(field.defaultValue)
-          ]);
-        } else if (typeof field.defaultValue === "string") {
-          addFieldAttribute(df, "@default", [
-            createStringAttributeArg(field.defaultValue)
-          ]);
-        } else if (typeof field.defaultValue === "number") {
-          addFieldAttribute(df, "@default", [
-            createNumberAttributeArg(field.defaultValue)
-          ]);
-        } else if (typeof field.defaultValue === "function") {
-          const defaultVal = field.defaultValue();
-          if (defaultVal instanceof Date) {
-            addDefaultNow(df);
-          } else {
-            console.warn(`Warning: Unsupported default function for field ${fieldName} in model ${table.modelName}. Please adjust manually.`);
-          }
-        }
-      }
-      if (fieldName === "updatedAt" && field.onUpdate) {
-        addFieldAttribute(df, "@updatedAt");
-      } else if (field.onUpdate) {
-        console.warn(`Warning: 'onUpdate' is only supported on 'updatedAt' fields. Please adjust manually for field ${fieldName} in model ${table.modelName}.`);
-      }
-    } else {
-      addModelField(dataModel, fieldName, numericId ? "Int" : "String", false, !field.required);
-      const referencedOriginalModelName = field.references.model;
-      const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
-      const relationField = {
-        $type: "DataField",
-        name: (0, import_common_helpers.lowerCaseFirst)(referencedCustomModelName),
-        attributes: [],
-        comments: [],
-        $container: dataModel
-      };
-      relationField.type = {
-        $type: "DataFieldType",
-        reference: {
-          $refText: (0, import_common_helpers.upperCaseFirst)(referencedCustomModelName)
-        },
-        array: field.type.endsWith("[]"),
-        optional: !field.required,
-        $container: relationField
-      };
-      let action = "Cascade";
-      if (field.references.onDelete === "no action") action = "NoAction";
-      else if (field.references.onDelete === "set null") action = "SetNull";
-      else if (field.references.onDelete === "set default") action = "SetDefault";
-      else if (field.references.onDelete === "restrict") action = "Restrict";
-      const relationAttr = {
-        $type: "DataFieldAttribute",
-        decl: {
-          $refText: "@relation"
-        },
-        args: [],
-        $container: relationField
-      };
-      const fieldsArg = {
-        $type: "AttributeArg",
-        name: "fields",
-        $container: relationAttr
-      };
-      const fieldsExpr = {
-        $type: "ArrayExpr",
-        items: [],
-        $container: fieldsArg
-      };
-      const fkRefExpr = {
-        $type: "ReferenceExpr",
-        args: [],
-        $container: fieldsExpr,
-        target: {
-          $refText: fieldName
-        }
-      };
-      fieldsExpr.items.push(fkRefExpr);
-      fieldsArg.value = fieldsExpr;
-      const referencesArg = {
-        $type: "AttributeArg",
-        name: "references",
-        $container: relationAttr
-      };
-      const referencesExpr = {
-        $type: "ArrayExpr",
-        items: [],
-        $container: referencesArg
-      };
-      const pkRefExpr = {
-        $type: "ReferenceExpr",
-        args: [],
-        $container: referencesExpr,
-        target: {
-          $refText: field.references.field
-        }
-      };
-      referencesExpr.items.push(pkRefExpr);
-      referencesArg.value = referencesExpr;
-      const onDeleteArg = {
-        $type: "AttributeArg",
-        name: "onDelete",
-        $container: relationAttr
-      };
-      const onDeleteValueExpr = {
-        $type: "ReferenceExpr",
-        target: {
-          $refText: action
-        },
-        args: [],
-        $container: onDeleteArg
-      };
-      onDeleteArg.value = onDeleteValueExpr;
-      relationAttr.args.push(...[
-        fieldsArg,
-        referencesArg,
-        onDeleteArg
-      ]);
-      relationField.attributes.push(relationAttr);
-      dataModel.fields.push(relationField);
-    }
-  }
-  if (toManyRelations.has(modelName)) {
-    const relations = toManyRelations.get(modelName);
-    for (const relatedModel of relations) {
-      const relationName = `${(0, import_common_helpers.lowerCaseFirst)(relatedModel)}s`;
-      if (!dataModel.fields.some((f) => f.name === relationName)) {
-        const relationField = {
-          $type: "DataField",
-          name: relationName,
-          attributes: [],
-          comments: [],
-          $container: dataModel
-        };
-        const relationType = {
-          $type: "DataFieldType",
-          reference: {
-            $refText: relatedModel
-          },
-          array: true,
-          optional: false,
-          $container: relationField
-        };
-        relationField.type = relationType;
-        dataModel.fields.push(relationField);
-      }
-    }
-  }
-  return changed;
+	let changed = false;
+	const modelName = (0, _zenstackhq_common_helpers.upperCaseFirst)(tables[tableName]?.modelName ?? tableName);
+	let dataModel = zmodel.declarations.find((d) => (0, _zenstackhq_language_ast.isDataModel)(d) && d.name === modelName);
+	if (!dataModel) {
+		changed = true;
+		dataModel = createDataModel(modelName, zmodel, numericId);
+		zmodel.declarations.push(dataModel);
+	}
+	if (modelName !== tableName && !(0, _zenstackhq_language_utils.hasAttribute)(dataModel, "@@map")) addModelAttribute(dataModel, "@@map", [createStringAttributeArg(tableName)]);
+	for (const [fName, field] of Object.entries(table.fields)) {
+		const fieldName = field.fieldName ?? fName;
+		if (dataModel.fields.some((f) => f.name === fieldName)) continue;
+		changed = true;
+		if (!field.references) {
+			const { array, type } = getMappedFieldType(field);
+			const df = {
+				$type: "DataField",
+				name: fieldName,
+				attributes: [],
+				comments: [],
+				$container: dataModel
+			};
+			df.type = {
+				$type: "DataFieldType",
+				type,
+				array: !!array,
+				optional: !field.required,
+				$container: df
+			};
+			dataModel.fields.push(df);
+			if (fieldName === "id") addFieldAttribute(df, "@id");
+			if (field.unique) addFieldAttribute(df, "@unique");
+			if (field.defaultValue !== void 0) {
+				if (fieldName === "createdAt") addDefaultNow(df);
+				else if (typeof field.defaultValue === "boolean") addFieldAttribute(df, "@default", [createBooleanAttributeArg(field.defaultValue)]);
+				else if (typeof field.defaultValue === "string") addFieldAttribute(df, "@default", [createStringAttributeArg(field.defaultValue)]);
+				else if (typeof field.defaultValue === "number") addFieldAttribute(df, "@default", [createNumberAttributeArg(field.defaultValue)]);
+				else if (typeof field.defaultValue === "function") if (field.defaultValue() instanceof Date) addDefaultNow(df);
+				else console.warn(`Warning: Unsupported default function for field ${fieldName} in model ${table.modelName}. Please adjust manually.`);
+			}
+			if (fieldName === "updatedAt" && field.onUpdate) addFieldAttribute(df, "@updatedAt");
+			else if (field.onUpdate) console.warn(`Warning: 'onUpdate' is only supported on 'updatedAt' fields. Please adjust manually for field ${fieldName} in model ${table.modelName}.`);
+		} else {
+			addModelField(dataModel, fieldName, numericId ? "Int" : "String", false, !field.required);
+			const referencedOriginalModelName = field.references.model;
+			const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
+			const relationField = {
+				$type: "DataField",
+				name: (0, _zenstackhq_common_helpers.lowerCaseFirst)(referencedCustomModelName),
+				attributes: [],
+				comments: [],
+				$container: dataModel
+			};
+			relationField.type = {
+				$type: "DataFieldType",
+				reference: { $refText: (0, _zenstackhq_common_helpers.upperCaseFirst)(referencedCustomModelName) },
+				array: field.type.endsWith("[]"),
+				optional: !field.required,
+				$container: relationField
+			};
+			let action = "Cascade";
+			if (field.references.onDelete === "no action") action = "NoAction";
+			else if (field.references.onDelete === "set null") action = "SetNull";
+			else if (field.references.onDelete === "set default") action = "SetDefault";
+			else if (field.references.onDelete === "restrict") action = "Restrict";
+			const relationAttr = {
+				$type: "DataFieldAttribute",
+				decl: { $refText: "@relation" },
+				args: [],
+				$container: relationField
+			};
+			const fieldsArg = {
+				$type: "AttributeArg",
+				name: "fields",
+				$container: relationAttr
+			};
+			const fieldsExpr = {
+				$type: "ArrayExpr",
+				items: [],
+				$container: fieldsArg
+			};
+			const fkRefExpr = {
+				$type: "ReferenceExpr",
+				args: [],
+				$container: fieldsExpr,
+				target: { $refText: fieldName }
+			};
+			fieldsExpr.items.push(fkRefExpr);
+			fieldsArg.value = fieldsExpr;
+			const referencesArg = {
+				$type: "AttributeArg",
+				name: "references",
+				$container: relationAttr
+			};
+			const referencesExpr = {
+				$type: "ArrayExpr",
+				items: [],
+				$container: referencesArg
+			};
+			const pkRefExpr = {
+				$type: "ReferenceExpr",
+				args: [],
+				$container: referencesExpr,
+				target: { $refText: field.references.field }
+			};
+			referencesExpr.items.push(pkRefExpr);
+			referencesArg.value = referencesExpr;
+			const onDeleteArg = {
+				$type: "AttributeArg",
+				name: "onDelete",
+				$container: relationAttr
+			};
+			onDeleteArg.value = {
+				$type: "ReferenceExpr",
+				target: { $refText: action },
+				args: [],
+				$container: onDeleteArg
+			};
+			relationAttr.args.push(...[
+				fieldsArg,
+				referencesArg,
+				onDeleteArg
+			]);
+			relationField.attributes.push(relationAttr);
+			dataModel.fields.push(relationField);
+		}
+	}
+	if (toManyRelations.has(modelName)) {
+		const relations = toManyRelations.get(modelName);
+		for (const relatedModel of relations) {
+			const relationName = `${(0, _zenstackhq_common_helpers.lowerCaseFirst)(relatedModel)}s`;
+			if (!dataModel.fields.some((f) => f.name === relationName)) {
+				const relationField = {
+					$type: "DataField",
+					name: relationName,
+					attributes: [],
+					comments: [],
+					$container: dataModel
+				};
+				relationField.type = {
+					$type: "DataFieldType",
+					reference: { $refText: relatedModel },
+					array: true,
+					optional: false,
+					$container: relationField
+				};
+				dataModel.fields.push(relationField);
+			}
+		}
+	}
+	return changed;
 }
-__name(addOrUpdateModel, "addOrUpdateModel");
 function addModelAttribute(dataModel, name, args = []) {
-  const attr = {
-    $type: "DataModelAttribute",
-    decl: {
-      $refText: name
-    },
-    $container: dataModel,
-    args: []
-  };
-  const finalArgs = args.map((arg) => ({
-    ...arg,
-    $container: attr
-  }));
-  attr.args.push(...finalArgs);
-  dataModel.attributes.push(attr);
+	const attr = {
+		$type: "DataModelAttribute",
+		decl: { $refText: name },
+		$container: dataModel,
+		args: []
+	};
+	const finalArgs = args.map((arg) => ({
+		...arg,
+		$container: attr
+	}));
+	attr.args.push(...finalArgs);
+	dataModel.attributes.push(attr);
 }
-__name(addModelAttribute, "addModelAttribute");
 function addFieldAttribute(dataField, name, args = []) {
-  const attr = {
-    $type: "DataFieldAttribute",
-    decl: {
-      $refText: name
-    },
-    $container: dataField,
-    args: []
-  };
-  const finalArgs = args.map((arg) => ({
-    ...arg,
-    $container: attr
-  }));
-  attr.args.push(...finalArgs);
-  dataField.attributes.push(attr);
+	const attr = {
+		$type: "DataFieldAttribute",
+		decl: { $refText: name },
+		$container: dataField,
+		args: []
+	};
+	const finalArgs = args.map((arg) => ({
+		...arg,
+		$container: attr
+	}));
+	attr.args.push(...finalArgs);
+	dataField.attributes.push(attr);
 }
-__name(addFieldAttribute, "addFieldAttribute");
 function createBooleanAttributeArg(value) {
-  const arg = {
-    $type: "AttributeArg"
-  };
-  const expr = {
-    $type: "BooleanLiteral",
-    value,
-    $container: arg
-  };
-  arg.value = expr;
-  return arg;
+	const arg = { $type: "AttributeArg" };
+	arg.value = {
+		$type: "BooleanLiteral",
+		value,
+		$container: arg
+	};
+	return arg;
 }
-__name(createBooleanAttributeArg, "createBooleanAttributeArg");
 function createNumberAttributeArg(value) {
-  const arg = {
-    $type: "AttributeArg"
-  };
-  const expr = {
-    $type: "NumberLiteral",
-    value: value.toString(),
-    $container: arg
-  };
-  arg.value = expr;
-  return arg;
+	const arg = { $type: "AttributeArg" };
+	arg.value = {
+		$type: "NumberLiteral",
+		value: value.toString(),
+		$container: arg
+	};
+	return arg;
 }
-__name(createNumberAttributeArg, "createNumberAttributeArg");
 function createStringAttributeArg(value) {
-  const arg = {
-    $type: "AttributeArg"
-  };
-  const expr = {
-    $type: "StringLiteral",
-    value,
-    $container: arg
-  };
-  arg.value = expr;
-  return arg;
+	const arg = { $type: "AttributeArg" };
+	arg.value = {
+		$type: "StringLiteral",
+		value,
+		$container: arg
+	};
+	return arg;
 }
-__name(createStringAttributeArg, "createStringAttributeArg");
+//#endregion
+//#region src/adapter.ts
+/**
+* Create a Better-Auth adapter for ZenStack ORM.
+* @param db ZenStack ORM client instance
+* @param config adapter configuration options
+*/
+const zenstackAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db) => ({ getFieldName, options }) => {
+		const convertSelect = (select, model) => {
+			if (!select || !model) return void 0;
+			return select.reduce((prev, cur) => {
+				return {
+					...prev,
+					[getFieldName({
+						model,
+						field: cur
+					})]: true
+				};
+			}, {});
+		};
+		function operatorToORMOperator(operator) {
+			switch (operator) {
+				case "starts_with": return "startsWith";
+				case "ends_with": return "endsWith";
+				case "ne": return "not";
+				case "not_in": return "notIn";
+				default: return operator;
+			}
+		}
+		const convertWhereClause = (model, where) => {
+			if (!where || !where.length) return {};
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) throw new _better_auth_core_error.BetterAuthError("Invalid where clause");
+				return { [getFieldName({
+					model,
+					field: w.field
+				})]: w.operator === "eq" || !w.operator ? w.value : { [operatorToORMOperator(w.operator)]: w.value } };
+			}
+			const and = where.filter((w) => w.connector === "AND" || !w.connector);
+			const or = where.filter((w) => w.connector === "OR");
+			const andClause = and.map((w) => {
+				return { [getFieldName({
+					model,
+					field: w.field
+				})]: w.operator === "eq" || !w.operator ? w.value : { [operatorToORMOperator(w.operator)]: w.value } };
+			});
+			const orClause = or.map((w) => {
+				return { [getFieldName({
+					model,
+					field: w.field
+				})]: w.operator === "eq" || !w.operator ? w.value : { [operatorToORMOperator(w.operator)]: w.value } };
+			});
+			return {
+				...andClause.length ? { AND: andClause } : {},
+				...orClause.length ? { OR: orClause } : {}
+			};
+		};
+		function requireModelDb(db, model) {
+			const modelDb = db[model];
+			if (!modelDb) throw new _better_auth_core_error.BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the ZenStack schema, you need to run 'npx zen generate'`);
+			return modelDb;
+		}
+		return {
+			async create({ model, data: values, select }) {
+				return await requireModelDb(db, model).create({
+					data: values,
+					select: convertSelect(select, model)
+				});
+			},
+			async findOne({ model, where, select }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				return await modelDb.findFirst({
+					where: whereClause,
+					select: convertSelect(select, model)
+				});
+			},
+			async findMany({ model, where, limit, offset, sortBy }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				return await modelDb.findMany({
+					where: whereClause,
+					take: limit || 100,
+					skip: offset || 0,
+					...sortBy?.field ? { orderBy: { [getFieldName({
+						model,
+						field: sortBy.field
+					})]: sortBy.direction === "desc" ? "desc" : "asc" } } : {}
+				});
+			},
+			async count({ model, where }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				return await modelDb.count({ where: whereClause });
+			},
+			async update({ model, where, update }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				return await modelDb.update({
+					where: whereClause,
+					data: update
+				});
+			},
+			async updateMany({ model, where, update }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				const result = await modelDb.updateMany({
+					where: whereClause,
+					data: update
+				});
+				return result ? result.count : 0;
+			},
+			async delete({ model, where }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				try {
+					await modelDb.delete({ where: whereClause });
+				} catch {}
+			},
+			async deleteMany({ model, where }) {
+				const modelDb = requireModelDb(db, model);
+				const whereClause = convertWhereClause(model, where);
+				const result = await modelDb.deleteMany({ where: whereClause });
+				return result ? result.count : 0;
+			},
+			options: config,
+			createSchema: async ({ file, tables }) => {
+				return generateSchema(file, tables, config, options);
+			}
+		};
+	};
+	const adapterOptions = {
+		config: {
+			adapterId: "zenstack",
+			adapterName: "ZenStack Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			transaction: (cb) => db.$transaction((tx) => {
+				return cb((0, better_auth_adapters.createAdapterFactory)({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(tx)
+				})(lazyOptions));
+			})
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = (0, better_auth_adapters.createAdapterFactory)(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+//#endregion
+exports.zenstackAdapter = zenstackAdapter;
 
-// src/adapter.ts
-var zenstackAdapter = /* @__PURE__ */ __name((db, config) => {
-  let lazyOptions = null;
-  const createCustomAdapter = /* @__PURE__ */ __name((db2) => ({ getFieldName, options }) => {
-    const convertSelect = /* @__PURE__ */ __name((select, model) => {
-      if (!select || !model) return void 0;
-      return select.reduce((prev, cur) => {
-        return {
-          ...prev,
-          [getFieldName({
-            model,
-            field: cur
-          })]: true
-        };
-      }, {});
-    }, "convertSelect");
-    function operatorToORMOperator(operator) {
-      switch (operator) {
-        case "starts_with":
-          return "startsWith";
-        case "ends_with":
-          return "endsWith";
-        case "ne":
-          return "not";
-        case "not_in":
-          return "notIn";
-        default:
-          return operator;
-      }
-    }
-    __name(operatorToORMOperator, "operatorToORMOperator");
-    const convertWhereClause = /* @__PURE__ */ __name((model, where) => {
-      if (!where || !where.length) return {};
-      if (where.length === 1) {
-        const w = where[0];
-        if (!w) {
-          throw new import_error.BetterAuthError("Invalid where clause");
-        }
-        return {
-          [getFieldName({
-            model,
-            field: w.field
-          })]: w.operator === "eq" || !w.operator ? w.value : {
-            [operatorToORMOperator(w.operator)]: w.value
-          }
-        };
-      }
-      const and = where.filter((w) => w.connector === "AND" || !w.connector);
-      const or = where.filter((w) => w.connector === "OR");
-      const andClause = and.map((w) => {
-        return {
-          [getFieldName({
-            model,
-            field: w.field
-          })]: w.operator === "eq" || !w.operator ? w.value : {
-            [operatorToORMOperator(w.operator)]: w.value
-          }
-        };
-      });
-      const orClause = or.map((w) => {
-        return {
-          [getFieldName({
-            model,
-            field: w.field
-          })]: w.operator === "eq" || !w.operator ? w.value : {
-            [operatorToORMOperator(w.operator)]: w.value
-          }
-        };
-      });
-      return {
-        ...andClause.length ? {
-          AND: andClause
-        } : {},
-        ...orClause.length ? {
-          OR: orClause
-        } : {}
-      };
-    }, "convertWhereClause");
-    function requireModelDb(db3, model) {
-      const modelDb = db3[model];
-      if (!modelDb) {
-        throw new import_error.BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the ZenStack schema, you need to run 'npx zen generate'`);
-      }
-      return modelDb;
-    }
-    __name(requireModelDb, "requireModelDb");
-    return {
-      async create({ model, data: values, select }) {
-        const modelDb = requireModelDb(db2, model);
-        return await modelDb.create({
-          data: values,
-          select: convertSelect(select, model)
-        });
-      },
-      async findOne({ model, where, select }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        return await modelDb.findFirst({
-          where: whereClause,
-          select: convertSelect(select, model)
-        });
-      },
-      async findMany({ model, where, limit, offset, sortBy }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        return await modelDb.findMany({
-          where: whereClause,
-          take: limit || 100,
-          skip: offset || 0,
-          ...sortBy?.field ? {
-            orderBy: {
-              [getFieldName({
-                model,
-                field: sortBy.field
-              })]: sortBy.direction === "desc" ? "desc" : "asc"
-            }
-          } : {}
-        });
-      },
-      async count({ model, where }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        return await modelDb.count({
-          where: whereClause
-        });
-      },
-      async update({ model, where, update }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        return await modelDb.update({
-          where: whereClause,
-          data: update
-        });
-      },
-      async updateMany({ model, where, update }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        const result = await modelDb.updateMany({
-          where: whereClause,
-          data: update
-        });
-        return result ? result.count : 0;
-      },
-      async delete({ model, where }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        try {
-          await modelDb.delete({
-            where: whereClause
-          });
-        } catch {
-        }
-      },
-      async deleteMany({ model, where }) {
-        const modelDb = requireModelDb(db2, model);
-        const whereClause = convertWhereClause(model, where);
-        const result = await modelDb.deleteMany({
-          where: whereClause
-        });
-        return result ? result.count : 0;
-      },
-      options: config,
-      createSchema: /* @__PURE__ */ __name(async ({ file, tables }) => {
-        return generateSchema(file, tables, config, options);
-      }, "createSchema")
-    };
-  }, "createCustomAdapter");
-  const adapterOptions = {
-    config: {
-      adapterId: "zenstack",
-      adapterName: "ZenStack Adapter",
-      usePlural: config.usePlural ?? false,
-      debugLogs: config.debugLogs ?? false,
-      transaction: /* @__PURE__ */ __name((cb) => db.$transaction((tx) => {
-        const adapter2 = (0, import_adapters.createAdapterFactory)({
-          config: adapterOptions.config,
-          adapter: createCustomAdapter(tx)
-        })(lazyOptions);
-        return cb(adapter2);
-      }), "transaction")
-    },
-    adapter: createCustomAdapter(db)
-  };
-  const adapter = (0, import_adapters.createAdapterFactory)(adapterOptions);
-  return (options) => {
-    lazyOptions = options;
-    return adapter(options);
-  };
-}, "zenstackAdapter");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  zenstackAdapter
-});
 //# sourceMappingURL=index.cjs.map