@zenstackhq/better-auth 3.5.6 → 3.6.1

package/dist/index.d.ts

@@ -1,34 +0,0 @@
-import { BetterAuthOptions } from '@better-auth/core';
-import { DBAdapterDebugLogOption, DBAdapter } from '@better-auth/core/db/adapter';
-import { ClientContract } from '@zenstackhq/orm';
-import { SchemaDef } from '@zenstackhq/orm/schema';
-
-/**
- * Options for the ZenStack adapter factory.
- */
-interface AdapterConfig {
-    /**
-     * Database provider
-     */
-    provider: 'sqlite' | 'postgresql';
-    /**
-     * Enable debug logs for the adapter
-     *
-     * @default false
-     */
-    debugLogs?: DBAdapterDebugLogOption | undefined;
-    /**
-     * Use plural table names
-     *
-     * @default false
-     */
-    usePlural?: boolean | undefined;
-}
-/**
- * Create a Better-Auth adapter for ZenStack ORM.
- * @param db ZenStack ORM client instance
- * @param config adapter configuration options
- */
-declare const zenstackAdapter: <Schema extends SchemaDef>(db: ClientContract<Schema>, config: AdapterConfig) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
-
-export { type AdapterConfig, zenstackAdapter };

package/dist/index.js

@@ -1,686 +0,0 @@
-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
-  })).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 = 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 === "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: 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 createNumberAttributeArg(value) {
-  const arg = {
-    $type: "AttributeArg"
-  };
-  const expr = {
-    $type: "NumberLiteral",
-    value: value.toString(),
-    $container: arg
-  };
-  arg.value = expr;
-  return arg;
-}
-__name(createNumberAttributeArg, "createNumberAttributeArg");
-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