@zenstackhq/better-auth 3.0.0-beta.24

package/dist/index.js

@@ -0,0 +1,661 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/adapter.ts
+import { BetterAuthError } from "@better-auth/core/error";
+import { createAdapterFactory } from "better-auth/adapters";
+
+// src/schema-generator.ts
+import { lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { formatDocument, loadDocument, ZModelCodeGenerator } from "@zenstackhq/language";
+import { isDataModel } from "@zenstackhq/language/ast";
+import { hasAttribute } from "@zenstackhq/language/utils";
+import fs from "fs";
+import { match } from "ts-pattern";
+async function generateSchema(file, tables, config, options) {
+  let filePath = file;
+  if (!filePath) {
+    if (fs.existsSync("./schema.zmodel")) {
+      filePath = "./schema.zmodel";
+    } else {
+      filePath = "./zenstack/schema.zmodel";
+    }
+  }
+  const schemaExists = fs.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 (fs.existsSync(schemaPath)) {
+    const loadResult = await 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 = upperCaseFirst(referencedCustomModel);
+        if (!toManyRelations.has(referencedModelNameCap)) {
+          toManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
+        }
+        const currentCustomModel = table.modelName ?? tableName;
+        const currentModelNameCap = 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 ZModelCodeGenerator();
+  let content = generator.generate(zmodel);
+  try {
+    content = await 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
+  ]);
+}
+__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;
+}
+__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;
+}
+__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;
+}
+__name(initializeZmodel, "initializeZmodel");
+function getMappedFieldType({ bigint, type }) {
+  return 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
+  })).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 = upperCaseFirst(customModelName);
+  let dataModel = zmodel.declarations.find((d) => isDataModel(d) && d.name === modelName);
+  if (!dataModel) {
+    changed = true;
+    dataModel = createDataModel(modelName, zmodel, numericId);
+    zmodel.declarations.push(dataModel);
+  }
+  if (modelName !== tableName && !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 === "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: lowerCaseFirst(referencedCustomModelName),
+        attributes: [],
+        comments: [],
+        $container: dataModel
+      };
+      relationField.type = {
+        $type: "DataFieldType",
+        reference: {
+          $refText: 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 = `${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;
+}
+__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);
+}
+__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);
+}
+__name(addFieldAttribute, "addFieldAttribute");
+function createBooleanAttributeArg(value) {
+  const arg = {
+    $type: "AttributeArg"
+  };
+  const expr = {
+    $type: "BooleanLiteral",
+    value,
+    $container: arg
+  };
+  arg.value = expr;
+  return arg;
+}
+__name(createBooleanAttributeArg, "createBooleanAttributeArg");
+function createStringAttributeArg(value) {
+  const arg = {
+    $type: "AttributeArg"
+  };
+  const expr = {
+    $type: "StringLiteral",
+    value,
+    $container: arg
+  };
+  arg.value = expr;
+  return arg;
+}
+__name(createStringAttributeArg, "createStringAttributeArg");
+
+// 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 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 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 = createAdapterFactory({
+          config: adapterOptions.config,
+          adapter: createCustomAdapter(tx)
+        })(lazyOptions);
+        return cb(adapter2);
+      }), "transaction")
+    },
+    adapter: createCustomAdapter(db)
+  };
+  const adapter = createAdapterFactory(adapterOptions);
+  return (options) => {
+    lazyOptions = options;
+    return adapter(options);
+  };
+}, "zenstackAdapter");
+export {
+  zenstackAdapter
+};
+//# sourceMappingURL=index.js.map