better-auth 0.0.2-beta.7 → 0.0.2

package/dist/access.d.ts

@@ -0,0 +1,4 @@
+export { A as AccessControl, a as AuthortizeResponse, P as ParsingError, R as Role, S as StatementsPrimitive, b as SubArray, c as Subset, d as adminAc, e as createAccessControl, f as defaultAc, g as defaultRoles, h as defaultStatements, m as memberAc, o as ownerAc } from './statement-COylZd3J.js';
+export { p as permissionFromString } from './index-Dg4eEXZW.js';
+import './helper-B5_2Vzba.js';
+import 'zod';

package/dist/access.js

@@ -0,0 +1,126 @@
+// src/plugins/organization/access/src/access.ts
+var ParsingError = class extends Error {
+  path;
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+  }
+};
+var AccessControl = class {
+  constructor(s) {
+    this.s = s;
+    this.statements = s;
+  }
+  statements;
+  newRole(statements) {
+    return new Role(statements);
+  }
+};
+var Role = class _Role {
+  statements;
+  constructor(statements) {
+    this.statements = statements;
+  }
+  authorize(request, connector) {
+    for (const [requestedResource, requestedActions] of Object.entries(
+      request
+    )) {
+      const allowedActions = this.statements[requestedResource];
+      if (!allowedActions) {
+        return {
+          success: false,
+          error: `You are not allowed to access resource: ${requestedResource}`
+        };
+      }
+      const success = connector === "OR" ? requestedActions.some(
+        (requestedAction) => allowedActions.includes(requestedAction)
+      ) : requestedActions.every(
+        (requestedAction) => allowedActions.includes(requestedAction)
+      );
+      if (success) {
+        return { success };
+      }
+      return {
+        success: false,
+        error: `unauthorized to access resource "${requestedResource}"`
+      };
+    }
+    return {
+      success: false,
+      error: "Not authorized"
+    };
+  }
+  static fromString(s) {
+    const statements = JSON.parse(s);
+    if (typeof statements !== "object") {
+      throw new ParsingError("statements is not an object", ".");
+    }
+    for (const [resource, actions] of Object.entries(statements)) {
+      if (typeof resource !== "string") {
+        throw new ParsingError("invalid resource identifier", resource);
+      }
+      if (!Array.isArray(actions)) {
+        throw new ParsingError("actions is not an array", resource);
+      }
+      for (let i = 0; i < actions.length; i++) {
+        if (typeof actions[i] !== "string") {
+          throw new ParsingError("action is not a string", `${resource}[${i}]`);
+        }
+      }
+    }
+    return new _Role(statements);
+  }
+  toString() {
+    return JSON.stringify(this.statements);
+  }
+};
+
+// src/plugins/organization/access/statement.ts
+var createAccessControl = (statements) => {
+  return new AccessControl(statements);
+};
+var defaultStatements = {
+  organization: ["update", "delete"],
+  member: ["create", "update", "delete"],
+  invitation: ["create", "cancel"]
+};
+var defaultAc = createAccessControl(defaultStatements);
+var adminAc = defaultAc.newRole({
+  organization: ["update"],
+  invitation: ["create", "cancel"],
+  member: ["create", "update", "delete"]
+});
+var ownerAc = defaultAc.newRole({
+  organization: ["update", "delete"],
+  member: ["create", "update", "delete"],
+  invitation: ["create", "cancel"]
+});
+var memberAc = defaultAc.newRole({
+  organization: [],
+  member: [],
+  invitation: []
+});
+var defaultRoles = {
+  admin: adminAc,
+  owner: ownerAc,
+  member: memberAc
+};
+
+// src/plugins/organization/access/utils.ts
+var permissionFromString = (permission) => {
+  return Role.fromString(permission ?? "");
+};
+export {
+  AccessControl,
+  ParsingError,
+  Role,
+  adminAc,
+  createAccessControl,
+  defaultAc,
+  defaultRoles,
+  defaultStatements,
+  memberAc,
+  ownerAc,
+  permissionFromString
+};
+//# sourceMappingURL=access.js.map

package/dist/access.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugins/organization/access/src/access.ts","../src/plugins/organization/access/statement.ts","../src/plugins/organization/access/utils.ts"],"sourcesContent":["import type { StatementsPrimitive as Statements, Subset } from \"./types\";\n\nexport class ParsingError extends Error {\n\tpublic readonly path: string;\n\tconstructor(message: string, path: string) {\n\t\tsuper(message);\n\t\tthis.path = path;\n\t}\n}\n\ntype Connector = \"OR\" | \"AND\";\n\nexport class AccessControl<TStatements extends Statements = Statements> {\n\tprivate readonly statements: TStatements;\n\tconstructor(private readonly s: TStatements) {\n\t\tthis.statements = s;\n\t}\n\tpublic newRole<K extends keyof TStatements>(\n\t\tstatements: Subset<K, TStatements>,\n\t) {\n\t\treturn new Role<Subset<K, TStatements>>(statements);\n\t}\n}\n\nexport type AuthortizeResponse =\n\t| { success: false; error: string }\n\t| { success: true; error?: never };\n\nexport class Role<TStatements extends Statements> {\n\tpublic readonly statements: TStatements;\n\n\tconstructor(statements: TStatements) {\n\t\tthis.statements = statements;\n\t}\n\n\tpublic authorize<K extends keyof TStatements>(\n\t\trequest: Subset<K, TStatements>,\n\t\tconnector?: Connector,\n\t): AuthortizeResponse {\n\t\tfor (const [requestedResource, requestedActions] of Object.entries(\n\t\t\trequest,\n\t\t)) {\n\t\t\tconst allowedActions = this.statements[requestedResource];\n\t\t\tif (!allowedActions) {\n\t\t\t\treturn {\n\t\t\t\t\tsuccess: false,\n\t\t\t\t\terror: `You are not allowed to access resource: ${requestedResource}`,\n\t\t\t\t};\n\t\t\t}\n\t\t\tconst success =\n\t\t\t\tconnector === \"OR\"\n\t\t\t\t\t? (requestedActions as string[]).some((requestedAction) =>\n\t\t\t\t\t\t\tallowedActions.includes(requestedAction),\n\t\t\t\t\t\t)\n\t\t\t\t\t: (requestedActions as string[]).every((requestedAction) =>\n\t\t\t\t\t\t\tallowedActions.includes(requestedAction),\n\t\t\t\t\t\t);\n\t\t\tif (success) {\n\t\t\t\treturn { success };\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tsuccess: false,\n\t\t\t\terror: `unauthorized to access resource \"${requestedResource}\"`,\n\t\t\t};\n\t\t}\n\t\treturn {\n\t\t\tsuccess: false,\n\t\t\terror: \"Not authorized\",\n\t\t};\n\t}\n\n\tstatic fromString<TStatements extends Statements>(s: string) {\n\t\tconst statements = JSON.parse(s) as TStatements;\n\n\t\tif (typeof statements !== \"object\") {\n\t\t\tthrow new ParsingError(\"statements is not an object\", \".\");\n\t\t}\n\t\tfor (const [resource, actions] of Object.entries(statements)) {\n\t\t\tif (typeof resource !== \"string\") {\n\t\t\t\tthrow new ParsingError(\"invalid resource identifier\", resource);\n\t\t\t}\n\t\t\tif (!Array.isArray(actions)) {\n\t\t\t\tthrow new ParsingError(\"actions is not an array\", resource);\n\t\t\t}\n\t\t\tfor (let i = 0; i < actions.length; i++) {\n\t\t\t\tif (typeof actions[i] !== \"string\") {\n\t\t\t\t\tthrow new ParsingError(\"action is not a string\", `${resource}[${i}]`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn new Role<TStatements>(statements);\n\t}\n\n\tpublic toString(): string {\n\t\treturn JSON.stringify(this.statements);\n\t}\n}\n","import { AccessControl } from \"./src/access\";\nimport type { StatementsPrimitive } from \"./src/types\";\n\nexport const createAccessControl = <S extends StatementsPrimitive>(\n\tstatements: S,\n) => {\n\treturn new AccessControl<S>(statements);\n};\n\nexport const defaultStatements = {\n\torganization: [\"update\", \"delete\"],\n\tmember: [\"create\", \"update\", \"delete\"],\n\tinvitation: [\"create\", \"cancel\"],\n} as const;\n\nexport const defaultAc = createAccessControl(defaultStatements);\n\nexport const adminAc = defaultAc.newRole({\n\torganization: [\"update\"],\n\tinvitation: [\"create\", \"cancel\"],\n\tmember: [\"create\", \"update\", \"delete\"],\n});\n\nexport const ownerAc = defaultAc.newRole({\n\torganization: [\"update\", \"delete\"],\n\tmember: [\"create\", \"update\", \"delete\"],\n\tinvitation: [\"create\", \"cancel\"],\n});\n\nexport const memberAc = defaultAc.newRole({\n\torganization: [],\n\tmember: [],\n\tinvitation: [],\n});\n\nexport const defaultRoles = {\n\tadmin: adminAc,\n\towner: ownerAc,\n\tmember: memberAc,\n};\n","import { Role } from \"./src/access\";\n\nexport const permissionFromString = (permission?: string) => {\n\treturn Role.fromString(permission ?? \"\");\n};\n"],"mappings":"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","names":[]}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,553 @@
+// src/cli/index.ts
+import { Command as Command2 } from "commander";
+import "dotenv/config";
+
+// src/cli/commands/migrate.ts
+import { Command } from "commander";
+
+// src/cli/get-config.ts
+import path from "node:path";
+import jiti from "jiti";
+
+// src/utils/logger.ts
+import { createConsola } from "consola";
+var consola = createConsola({
+  formatOptions: {
+    date: false
+  }
+});
+var createLogger = (options) => {
+  return {
+    log: (...args) => {
+      !options?.disabled && consola.log("", ...args);
+    },
+    error: (...args) => {
+      !options?.disabled && consola.error("", ...args);
+    },
+    warn: (...args) => {
+      !options?.disabled && consola.warn("", ...args);
+    },
+    info: (...args) => {
+      !options?.disabled && consola.info("", ...args);
+    },
+    debug: (...args) => {
+      !options?.disabled && consola.debug("", ...args);
+    },
+    box: (...args) => {
+      !options?.disabled && consola.box("", ...args);
+    },
+    success: (...args) => {
+      !options?.disabled && consola.success("", ...args);
+    },
+    break: (...args) => {
+      !options?.disabled && console.log("\n");
+    }
+  };
+};
+var logger = createLogger();
+
+// src/cli/get-config.ts
+var possiblePaths = ["auth.ts", "auth.config.ts"];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `lib/${it}`),
+  ...possiblePaths.map((it) => `utils/${it}`)
+];
+possiblePaths = [...possiblePaths, ...possiblePaths.map((it) => `src/${it}`)];
+async function getConfig({
+  cwd,
+  configPath
+}) {
+  try {
+    let configFile = null;
+    if (configPath) {
+      const config = await jiti(cwd).import(
+        path.join(cwd, configPath),
+        {}
+      );
+      if (!config) {
+        return null;
+      }
+      configFile = config.auth.options;
+    }
+    for (const possiblePath of possiblePaths) {
+      try {
+        const config = await jiti(path.join(cwd, possiblePath)).import(
+          path.join(cwd, possiblePath),
+          {}
+        );
+        if (config) {
+          configFile = config.auth?.options || config.default?.options || null;
+          if (!configFile) {
+            logger.error("[#better-auth]: Couldn't read your auth config.");
+            logger.break();
+            logger.info(
+              "[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth."
+            );
+            process.exit(1);
+          }
+          break;
+        }
+      } catch (e) {
+        if (!(e instanceof Error && e.message.includes("Cannot find module"))) {
+          logger.error(e);
+          process.exit(1);
+        }
+      }
+    }
+    return configFile;
+  } catch (e) {
+    return null;
+  }
+}
+
+// src/cli/commands/migrate.ts
+import { z } from "zod";
+import { existsSync } from "fs";
+import path2 from "path";
+
+// src/adapters/kysely.ts
+import Database from "better-sqlite3";
+import { Kysely } from "kysely";
+import {
+  MysqlDialect,
+  PostgresDialect,
+  SqliteDialect
+} from "kysely";
+import { createPool } from "mysql2";
+import pg from "pg";
+var { Pool } = pg;
+var getDialect = (config) => {
+  if (!config.database) {
+    return null;
+  }
+  let dialect = null;
+  if ("provider" in config.database) {
+    const provider = config.database.provider;
+    const connectionString = config.database.url.trim();
+    if (provider === "postgres") {
+      const pool = new Pool({
+        connectionString
+      });
+      dialect = new PostgresDialect({
+        pool
+      });
+    }
+    if (provider === "mysql") {
+      const params = new URL(connectionString);
+      const pool = createPool({
+        host: params.hostname,
+        user: params.username,
+        password: params.password,
+        database: params.pathname.split("/")[1],
+        port: Number(params.port)
+      });
+      dialect = new MysqlDialect({ pool });
+    }
+    if (provider === "sqlite") {
+      const db = new Database(connectionString);
+      dialect = new SqliteDialect({
+        database: db
+      });
+    }
+  }
+  return dialect;
+};
+var createKyselyAdapter = (config) => {
+  const dialect = getDialect(config);
+  if (!dialect) {
+    return null;
+  }
+  const db = new Kysely({
+    dialect
+  });
+  return db;
+};
+var getDatabaseType = (config) => {
+  if ("provider" in config.database) {
+    return config.database.provider;
+  }
+  if ("dialect" in config.database) {
+    if (config.database.dialect instanceof PostgresDialect) {
+      return "postgres";
+    }
+    if (config.database.dialect instanceof MysqlDialect) {
+      return "mysql";
+    }
+    if (config.database.dialect instanceof SqliteDialect) {
+      return "sqlite";
+    }
+  }
+  return "sqlite";
+};
+
+// src/cli/commands/migrate.ts
+import ora from "ora";
+import chalk from "chalk";
+import prompts from "prompts";
+
+// src/adapters/get-tables.ts
+var getAuthTables = (options) => {
+  const pluginSchema = options.plugins?.reduce((acc, plugin) => {
+    const schema = plugin.schema;
+    return {
+      ...acc,
+      ...schema
+    };
+  }, {});
+  return {
+    ...pluginSchema,
+    user: {
+      tableName: options.user?.modelName || "user",
+      fields: {
+        name: {
+          type: "string"
+        },
+        email: {
+          type: "string"
+        },
+        emailVerified: {
+          type: "boolean",
+          defaultValue: () => false
+        },
+        image: {
+          type: "string",
+          required: false
+        },
+        createdAt: {
+          type: "date",
+          defaultValue: () => /* @__PURE__ */ new Date()
+        },
+        updatedAt: {
+          type: "date",
+          defaultValue: () => /* @__PURE__ */ new Date()
+        }
+      }
+    },
+    session: {
+      tableName: options.session?.modelName || "session",
+      fields: {
+        expiresAt: {
+          type: "date"
+        },
+        ipAddress: {
+          type: "string",
+          required: false
+        },
+        userAgent: {
+          type: "string",
+          required: false
+        },
+        userId: {
+          type: "string",
+          references: {
+            model: "user",
+            field: "id",
+            onDelete: "cascade"
+          }
+        }
+      }
+    },
+    account: {
+      tableName: options.account?.modelName || "account",
+      fields: {
+        accountId: {
+          type: "string"
+        },
+        providerId: {
+          type: "string"
+        },
+        userId: {
+          type: "string",
+          references: {
+            model: "user",
+            field: "id",
+            onDelete: "cascade"
+          }
+        },
+        accessToken: {
+          type: "string",
+          required: false
+        },
+        refreshToken: {
+          type: "string",
+          required: false
+        },
+        idToken: {
+          type: "string",
+          required: false
+        },
+        accessTokenExpiresAt: {
+          type: "date",
+          required: false
+        },
+        refreshTokenExpiresAt: {
+          type: "date",
+          required: false
+        },
+        password: {
+          type: "string",
+          required: false
+        }
+      }
+    }
+  };
+};
+
+// src/cli/utils/get-schema.ts
+function getPluginTable(config) {
+  const pluginsMigrations = config.plugins?.flatMap(
+    (plugin) => Object.keys(plugin.schema || {}).map((key) => {
+      const schema = plugin.schema || {};
+      const table = schema[key];
+      if (table?.disableMigration) {
+        return;
+      }
+      return {
+        tableName: key,
+        fields: table?.fields
+      };
+    }).filter((value) => value !== void 0)
+  ) || [];
+  return pluginsMigrations;
+}
+function getSchema(config) {
+  const baseSchema = getAuthTables(config);
+  const pluginSchema = getPluginTable(config);
+  const schema = [
+    ...pluginSchema,
+    baseSchema.user,
+    baseSchema.session,
+    baseSchema.account
+  ].reduce((acc, curr) => {
+    acc[curr.tableName] = {
+      fields: {
+        ...acc[curr.tableName]?.fields,
+        ...curr.fields
+      }
+    };
+    return acc;
+  }, {});
+  return schema;
+}
+
+// src/cli/utils/get-migration.ts
+var postgresMap = {
+  string: ["character varying", "text"],
+  number: [
+    "integer",
+    "bigint",
+    "smallint",
+    "numeric",
+    "real",
+    "double precision"
+  ],
+  boolean: ["boolean"],
+  date: ["timestamp", "date"]
+};
+var mysqlMap = {
+  string: ["varchar", "text"],
+  number: [
+    "integer",
+    "int",
+    "bigint",
+    "smallint",
+    "decimal",
+    "float",
+    "double"
+  ],
+  boolean: ["boolean"],
+  date: ["date", "datetime"]
+};
+var sqliteMap = {
+  string: ["TEXT"],
+  number: ["INTEGER", "REAL"],
+  boolean: ["INTEGER", "BOOLEAN"],
+  // 0 or 1
+  date: ["DATE", "INTEGER"]
+};
+var map = {
+  postgres: postgresMap,
+  mysql: mysqlMap,
+  sqlite: sqliteMap
+};
+function matchType(columnDataType, fieldType, dbType) {
+  const types = map[dbType];
+  const type = types[fieldType].map((t) => t.toLowerCase());
+  const matches = type.includes(columnDataType.toLowerCase());
+  return matches;
+}
+async function getMigrations(config) {
+  const betterAuthSchema = getSchema(config);
+  const dbType = getDatabaseType(config);
+  const db = createKyselyAdapter(config);
+  if (!db) {
+    logger.error("Invalid database configuration.");
+    process.exit(1);
+  }
+  const tableMetadata = await db.introspection.getTables();
+  const toBeCreated = [];
+  const toBeAdded = [];
+  for (const [key, value] of Object.entries(betterAuthSchema)) {
+    const table = tableMetadata.find((t) => t.name === key);
+    if (!table) {
+      const tIndex = toBeCreated.findIndex((t) => t.table === key);
+      if (tIndex === -1) {
+        toBeCreated.push({
+          table: key,
+          fields: value.fields
+        });
+      } else {
+        toBeCreated[tIndex].fields = {
+          ...toBeCreated[tIndex].fields,
+          ...value.fields
+        };
+      }
+      continue;
+    }
+    let toBeAddedFields = {};
+    for (const [fieldName, field] of Object.entries(value.fields)) {
+      const column = table.columns.find((c) => c.name === fieldName);
+      if (!column) {
+        toBeAddedFields[fieldName] = field;
+        continue;
+      }
+      if (matchType(column.dataType, field.type, dbType)) {
+        continue;
+      } else {
+        logger.warn(
+          `Field ${fieldName} in table ${key} has a different type in the database. Expected ${field.type} but got ${column.dataType}.`
+        );
+      }
+    }
+    if (Object.keys(toBeAddedFields).length > 0) {
+      toBeAdded.push({
+        table: key,
+        fields: toBeAddedFields
+      });
+    }
+  }
+  const typeMap = {
+    string: "text",
+    boolean: "boolean",
+    number: "integer",
+    date: "date"
+  };
+  const migrations = [];
+  if (toBeAdded.length) {
+    for (const table of toBeAdded) {
+      logger.info(`Adding fields to table ${table.table}`);
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        logger.info(`Adding field ${fieldName} with type ${field.type}`);
+        const type = typeMap[field.type];
+        const exec = db.schema.alterTable(table.table).addColumn(fieldName, type, (col) => {
+          col = field.required !== false ? col.notNull() : col;
+          if (field.references) {
+            col = col.references(
+              `${field.references.model}.${field.references.field}`
+            );
+          }
+          return col;
+        });
+        migrations.push(exec);
+      }
+    }
+  }
+  if (toBeCreated.length) {
+    for (const table of toBeCreated) {
+      let dbT = db.schema.createTable(table.table).addColumn("id", "text", (col) => col.primaryKey());
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        const type = typeMap[field.type];
+        dbT = dbT.addColumn(fieldName, type, (col) => {
+          col = field.required !== false ? col.notNull() : col;
+          if (field.references) {
+            col = col.references(
+              `${field.references.model}.${field.references.field}`
+            );
+          }
+          return col;
+        });
+      }
+      migrations.push(dbT);
+    }
+  }
+  async function runMigrations() {
+    return await Promise.all(migrations.map((m) => m.execute()));
+  }
+  return { toBeCreated, toBeAdded, runMigrations };
+}
+
+// src/cli/commands/migrate.ts
+var migrate = new Command("migrate").option(
+  "-c, --cwd <cwd>",
+  "the working directory. defaults to the current directory.",
+  process.cwd()
+).option(
+  "--config <config>",
+  "the path to the configuration file. defaults to the first configuration file found."
+).action(async (opts) => {
+  const options = z.object({
+    cwd: z.string(),
+    config: z.string().optional()
+  }).parse(opts);
+  const cwd = path2.resolve(options.cwd);
+  if (!existsSync(cwd)) {
+    logger.error(`The directory "${cwd}" does not exist.`);
+    process.exit(1);
+  }
+  const config = await getConfig({
+    cwd,
+    configPath: options.config
+  });
+  if (!config) {
+    logger.error("No configuration file found.");
+    return;
+  }
+  const db = createKyselyAdapter(config);
+  if (!db) {
+    logger.error("Invalid database configuration.");
+    process.exit(1);
+  }
+  const spinner = ora("preparing migration...").start();
+  const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
+  if (!toBeAdded.length && !toBeCreated.length) {
+    spinner.stop();
+    logger.success("\u{1F680} No migrations needed.");
+    process.exit(0);
+  }
+  spinner.stop();
+  logger.info(`\u{1F511} The migration will affect the following:`);
+  for (const table of [...toBeAdded, ...toBeCreated]) {
+    logger.info(
+      "->",
+      chalk.magenta(Object.keys(table.fields).join(", ")),
+      chalk.white("fields on"),
+      chalk.yellow(`${table.table}`),
+      chalk.white("table.")
+    );
+  }
+  const { migrate: migrate2 } = await prompts({
+    type: "confirm",
+    name: "migrate",
+    message: "Are you sure you want to run these migrations?",
+    initial: false
+  });
+  if (!migrate2) {
+    logger.info("Migration cancelled.");
+    process.exit(0);
+  }
+  spinner?.start("migrating...");
+  await runMigrations();
+  spinner.stop();
+  logger.success("\u{1F680} migration was completed successfully!");
+  process.exit(0);
+});
+
+// src/cli/index.ts
+async function main() {
+  const program = new Command2().name("better-auth");
+  program.addCommand(migrate);
+  program.parse();
+}
+main();
+//# sourceMappingURL=cli.js.map