@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/better/auth/(generators)/index.js

@@ -0,0 +1,18 @@
+import { logger } from "better-auth";
+import { generateDrizzleSchema } from "./drizzle.js";
+import { generateMigrations } from "./kysely.js";
+import { generatePrismaSchema } from "./prisma.js";
+export const adapters = {
+  prisma: generatePrismaSchema,
+  drizzle: generateDrizzleSchema,
+  kysely: generateMigrations
+};
+export const getGenerator = (opts) => {
+  const adapter = opts.adapter;
+  const generator = adapter.id in adapters ? adapters[adapter.id] : null;
+  if (!generator) {
+    logger.error(`${adapter.id} is not supported.`);
+    process.exit(1);
+  }
+  return generator(opts);
+};

package/bin/app/better/auth/(generators)/kysely.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaGenerator } from "./types";
+export declare const generateMigrations: SchemaGenerator;

package/bin/app/better/auth/(generators)/kysely.js

@@ -0,0 +1,9 @@
+import { getMigrations } from "better-auth/db";
+export const generateMigrations = async ({ options, file }) => {
+  const { compileMigrations } = await getMigrations(options);
+  const migrations = await compileMigrations();
+  return {
+    code: migrations,
+    fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
+  };
+};

package/bin/app/better/auth/(generators)/prisma.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaGenerator } from "./types";
+export declare const generatePrismaSchema: SchemaGenerator;

package/bin/app/better/auth/(generators)/prisma.js

@@ -0,0 +1,154 @@
+import { produceSchema } from "@mrleebo/prisma-ast";
+import { existsSync } from "@reliverse/relifso";
+import { capitalizeFirstLetter } from "better-auth";
+import { getAuthTables } from "better-auth/db";
+import fs from "fs/promises";
+import path from "path";
+export const generatePrismaSchema = async ({ adapter, options, file }) => {
+  const provider = adapter.options?.provider || "postgresql";
+  const tables = getAuthTables(options);
+  const filePath = file || "./prisma/schema.prisma";
+  const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+  let schemaPrisma = "";
+  if (schemaPrismaExist) {
+    schemaPrisma = await fs.readFile(path.join(process.cwd(), filePath), "utf-8");
+  } else {
+    schemaPrisma = getNewPrisma(provider);
+  }
+  const manyToManyRelations = /* @__PURE__ */ new Map();
+  for (const table in tables) {
+    const fields = tables[table]?.fields;
+    for (const field in fields) {
+      const attr = fields[field];
+      if (attr.references) {
+        const referencedModel = capitalizeFirstLetter(attr.references.model);
+        if (!manyToManyRelations.has(referencedModel)) {
+          manyToManyRelations.set(referencedModel, /* @__PURE__ */ new Set());
+        }
+        manyToManyRelations.get(referencedModel).add(capitalizeFirstLetter(table));
+      }
+    }
+  }
+  const schema = produceSchema(schemaPrisma, (builder) => {
+    for (const table in tables) {
+      let getType = function({
+        isBigint,
+        isOptional,
+        type
+      }) {
+        if (type === "string") {
+          return isOptional ? "String?" : "String";
+        }
+        if (type === "number" && isBigint) {
+          return isOptional ? "BigInt?" : "BigInt";
+        }
+        if (type === "number") {
+          return isOptional ? "Int?" : "Int";
+        }
+        if (type === "boolean") {
+          return isOptional ? "Boolean?" : "Boolean";
+        }
+        if (type === "date") {
+          return isOptional ? "DateTime?" : "DateTime";
+        }
+        if (type === "string[]") {
+          return isOptional ? "String[]" : "String[]";
+        }
+        if (type === "number[]") {
+          return isOptional ? "Int[]" : "Int[]";
+        }
+      };
+      const fields = tables[table]?.fields;
+      const originalTable = tables[table]?.modelName;
+      const modelName = capitalizeFirstLetter(originalTable || "");
+      const prismaModel = builder.findByType("model", {
+        name: modelName
+      });
+      if (!prismaModel) {
+        if (provider === "mongodb") {
+          builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
+        } else {
+          if (options.advanced?.database?.useNumberId) {
+            builder.model(modelName).field("id", "Int").attribute("id").attribute("default(autoincrement())");
+          } else {
+            builder.model(modelName).field("id", "String").attribute("id");
+          }
+        }
+      }
+      for (const field in fields) {
+        const attr = fields[field];
+        if (prismaModel) {
+          const isAlreadyExist = builder.findByType("field", {
+            name: field,
+            within: prismaModel.properties
+          });
+          if (isAlreadyExist) {
+            continue;
+          }
+        }
+        builder.model(modelName).field(
+          field,
+          field === "id" && options.advanced?.database?.useNumberId ? getType({
+            isBigint: false,
+            isOptional: false,
+            type: "number"
+          }) : getType({
+            isBigint: attr?.bigint || false,
+            isOptional: !attr?.required,
+            type: attr.references?.field === "id" ? options.advanced?.database?.useNumberId ? "number" : "string" : attr.type
+          })
+        );
+        if (attr.unique) {
+          builder.model(modelName).blockAttribute(`unique([${field}])`);
+        }
+        if (attr.references) {
+          let action = "Cascade";
+          if (attr.references.onDelete === "no action") action = "NoAction";
+          else if (attr.references.onDelete === "set null") action = "SetNull";
+          else if (attr.references.onDelete === "set default") action = "SetDefault";
+          else if (attr.references.onDelete === "restrict") action = "Restrict";
+          builder.model(modelName).field(
+            attr.references.model.toLowerCase(),
+            capitalizeFirstLetter(attr.references.model)
+          ).attribute(
+            `relation(fields: [${field}], references: [${attr.references.field}], onDelete: ${action})`
+          );
+        }
+        if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") {
+          builder.model(modelName).field(field).attribute("db.Text");
+        }
+      }
+      if (manyToManyRelations.has(modelName)) {
+        for (const relatedModel of manyToManyRelations.get(modelName)) {
+          const fieldName = `${relatedModel.toLowerCase()}s`;
+          const existingField = builder.findByType("field", {
+            name: fieldName,
+            within: prismaModel?.properties
+          });
+          if (!existingField) {
+            builder.model(modelName).field(fieldName, `${relatedModel}[]`);
+          }
+        }
+      }
+      const hasAttribute = builder.findByType("attribute", {
+        name: "map",
+        within: prismaModel?.properties
+      });
+      if (originalTable !== modelName && !hasAttribute) {
+        builder.model(modelName).blockAttribute("map", originalTable);
+      }
+    }
+  });
+  return {
+    code: schema.trim() === schemaPrisma.trim() ? "" : schema,
+    fileName: filePath,
+    overwrite: true
+  };
+};
+const getNewPrisma = (provider) => `generator client {
+    provider = "prisma-client-js"
+  }
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;

package/bin/app/better/auth/(generators)/types.d.ts

@@ -0,0 +1,11 @@
+import type { Adapter, BetterAuthOptions } from "better-auth";
+export type SchemaGenerator = (opts: {
+    file?: string;
+    adapter: Adapter;
+    options: BetterAuthOptions;
+}) => Promise<{
+    code?: string;
+    fileName: string;
+    overwrite?: boolean;
+    append?: boolean;
+}>;

package/bin/app/better/auth/(utils)/add-svelte-kit-env-modules.d.ts

@@ -0,0 +1,3 @@
+export declare function addSvelteKitEnvModules(aliases: Record<string, string>): void;
+export declare function filterPrivateEnv(publicPrefix: string, privatePrefix: string): Record<string, string>;
+export declare function filterPublicEnv(publicPrefix: string, privatePrefix: string): Record<string, string>;

package/bin/app/better/auth/(utils)/add-svelte-kit-env-modules.js

@@ -0,0 +1,91 @@
+export function addSvelteKitEnvModules(aliases) {
+  aliases["$env/dynamic/private"] = createDataUriModule(createDynamicEnvModule());
+  aliases["$env/dynamic/public"] = createDataUriModule(createDynamicEnvModule());
+  aliases["$env/static/private"] = createDataUriModule(
+    createStaticEnvModule(filterPrivateEnv("PUBLIC_", ""))
+  );
+  aliases["$env/static/public"] = createDataUriModule(
+    createStaticEnvModule(filterPublicEnv("PUBLIC_", ""))
+  );
+}
+function createDataUriModule(module) {
+  return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
+}
+function createStaticEnvModule(env) {
+  const declarations = Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`);
+  return `
+  ${declarations.join("\n")}
+  // jiti dirty hack: .unknown
+  `;
+}
+function createDynamicEnvModule() {
+  return `
+  export const env = process.env;
+  // jiti dirty hack: .unknown
+  `;
+}
+export function filterPrivateEnv(publicPrefix, privatePrefix) {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))
+    )
+  );
+}
+export function filterPublicEnv(publicPrefix, privatePrefix) {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix))
+    )
+  );
+}
+const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+const reserved = /* @__PURE__ */ new Set([
+  "do",
+  "if",
+  "in",
+  "for",
+  "let",
+  "new",
+  "try",
+  "var",
+  "case",
+  "else",
+  "enum",
+  "eval",
+  "null",
+  "this",
+  "true",
+  "void",
+  "with",
+  "await",
+  "break",
+  "catch",
+  "class",
+  "const",
+  "false",
+  "super",
+  "throw",
+  "while",
+  "yield",
+  "delete",
+  "export",
+  "import",
+  "public",
+  "return",
+  "static",
+  "switch",
+  "typeof",
+  "default",
+  "extends",
+  "finally",
+  "package",
+  "private",
+  "continue",
+  "debugger",
+  "function",
+  "arguments",
+  "interface",
+  "protected",
+  "implements",
+  "instanceof"
+]);

package/bin/app/better/auth/(utils)/check-package-managers.d.ts

@@ -0,0 +1,4 @@
+export declare function checkPackageManagers(): Promise<{
+    hasPnpm: boolean;
+    hasBun: boolean;
+}>;

package/bin/app/better/auth/(utils)/check-package-managers.js

@@ -0,0 +1,20 @@
+import { exec } from "child_process";
+function checkCommand(command) {
+  return new Promise((resolve) => {
+    exec(`${command} --version`, (error) => {
+      if (error) {
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+export async function checkPackageManagers() {
+  const hasPnpm = await checkCommand("pnpm");
+  const hasBun = await checkCommand("bun");
+  return {
+    hasPnpm,
+    hasBun
+  };
+}

package/bin/app/better/auth/(utils)/format-ms.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Only supports up to seconds.
+ */
+export declare function formatMilliseconds(ms: number): string;

package/bin/app/better/auth/(utils)/format-ms.js

@@ -0,0 +1,11 @@
+export function formatMilliseconds(ms) {
+  if (ms < 0) {
+    throw new Error("Milliseconds cannot be negative");
+  }
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  const seconds = Math.floor(ms / 1e3);
+  const milliseconds = ms % 1e3;
+  return `${seconds}s ${milliseconds}ms`;
+}

package/bin/app/better/auth/(utils)/generate-secret.d.ts

@@ -0,0 +1 @@
+export declare const generateSecretHash: () => any;

package/bin/app/better/auth/(utils)/generate-secret.js

@@ -0,0 +1,4 @@
+import Crypto from "crypto";
+export const generateSecretHash = () => {
+  return Crypto.randomBytes(32).toString("hex");
+};

package/bin/app/better/auth/(utils)/get-config.d.ts

@@ -0,0 +1,8 @@
+import type { BetterAuthOptions } from "better-auth";
+declare let possiblePaths: string[];
+export declare function getConfig({ cwd, configPath, shouldThrowOnError, }: {
+    cwd: string;
+    configPath?: string;
+    shouldThrowOnError?: boolean;
+}): Promise<BetterAuthOptions | null>;
+export { possiblePaths };

package/bin/app/better/auth/(utils)/get-config.js

@@ -0,0 +1,168 @@
+import babelPresetReact from "@babel/preset-react";
+import babelPresetTypeScript from "@babel/preset-typescript";
+import { pathExists } from "@reliverse/relifso";
+import { BetterAuthError, logger } from "better-auth";
+import { loadConfig } from "c12";
+import path from "path";
+import { addSvelteKitEnvModules } from "./add-svelte-kit-env-modules.js";
+import { getTsconfigInfo } from "./get-tsconfig-info.js";
+let possiblePaths = [
+  "auth.ts",
+  "auth.tsx",
+  "auth.js",
+  "auth.jsx",
+  "auth.server.js",
+  "auth.server.ts"
+];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `lib/server/${it}`),
+  ...possiblePaths.map((it) => `server/${it}`),
+  ...possiblePaths.map((it) => `lib/${it}`),
+  ...possiblePaths.map((it) => `utils/${it}`)
+];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `src/${it}`),
+  ...possiblePaths.map((it) => `app/${it}`)
+];
+async function getPathAliases(cwd) {
+  const tsConfigPath = path.join(cwd, "tsconfig.json");
+  if (!await pathExists(tsConfigPath)) {
+    return null;
+  }
+  try {
+    const tsConfig = await getTsconfigInfo(cwd);
+    const { paths = {}, baseUrl = "." } = tsConfig.compilerOptions || {};
+    const result = {};
+    const obj = Object.entries(paths);
+    for (const [alias, aliasPaths] of obj) {
+      for (const aliasedPath of aliasPaths) {
+        const resolvedBaseUrl = path.join(cwd, baseUrl);
+        const finalAlias = alias.endsWith("*") ? alias.slice(0, -1) : alias;
+        const finalAliasedPath = aliasedPath.endsWith("*") ? aliasedPath.slice(0, -1) : aliasedPath;
+        result[finalAlias || ""] = path.join(resolvedBaseUrl, finalAliasedPath);
+      }
+    }
+    addSvelteKitEnvModules(result);
+    return result;
+  } catch (error) {
+    console.error(error);
+    throw new BetterAuthError("Error parsing tsconfig.json");
+  }
+}
+const jitiOptions = async (cwd) => {
+  const alias = await getPathAliases(cwd) || {};
+  return {
+    transformOptions: {
+      babel: {
+        presets: [
+          [
+            babelPresetTypeScript,
+            {
+              isTSX: true,
+              allExtensions: true
+            }
+          ],
+          [babelPresetReact, { runtime: "automatic" }]
+        ]
+      }
+    },
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    alias
+  };
+};
+export async function getConfig({
+  cwd,
+  configPath,
+  shouldThrowOnError = false
+}) {
+  try {
+    let configFile = null;
+    if (configPath) {
+      let resolvedPath = path.join(cwd, configPath);
+      if (await pathExists(configPath)) resolvedPath = configPath;
+      const { config } = await loadConfig({
+        configFile: resolvedPath,
+        dotenv: true,
+        jitiOptions: await jitiOptions(cwd)
+      });
+      if (!config.auth && !config.default) {
+        if (shouldThrowOnError) {
+          throw new Error(
+            `Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`
+          );
+        }
+        logger.error(
+          `[#better-auth]: Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`
+        );
+        process.exit(1);
+      }
+      configFile = config.auth?.options || config.default?.options || null;
+    }
+    if (!configFile) {
+      for (const possiblePath of possiblePaths) {
+        try {
+          const { config } = await loadConfig({
+            configFile: possiblePath,
+            jitiOptions: await jitiOptions(cwd)
+          });
+          const hasConfig = Object.keys(config).length > 0;
+          if (hasConfig) {
+            configFile = config.auth?.options || config.default?.options || null;
+            if (!configFile) {
+              if (shouldThrowOnError) {
+                throw new Error(
+                  "Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth."
+                );
+              }
+              logger.error("[#better-auth]: Couldn't read your auth config.");
+              console.log("");
+              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 (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
+            if (shouldThrowOnError) {
+              throw new Error(
+                `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`
+              );
+            }
+            logger.error(
+              `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`
+            );
+            process.exit(1);
+          }
+          if (shouldThrowOnError) {
+            throw e;
+          }
+          logger.error("[#better-auth]: Couldn't read your auth config.", e);
+          process.exit(1);
+        }
+      }
+    }
+    return configFile;
+  } catch (e) {
+    if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
+      if (shouldThrowOnError) {
+        throw new Error(
+          `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`
+        );
+      }
+      logger.error(
+        `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`
+      );
+      process.exit(1);
+    }
+    if (shouldThrowOnError) {
+      throw e;
+    }
+    logger.error("Couldn't read your auth config.", e);
+    process.exit(1);
+  }
+}
+export { possiblePaths };

package/bin/app/better/auth/(utils)/get-package-info.d.ts

@@ -0,0 +1 @@
+export declare function getPackageInfo(cwd?: string): unknown;

package/bin/app/better/auth/(utils)/get-package-info.js

@@ -0,0 +1,6 @@
+import fs from "@reliverse/relifso";
+import path from "path";
+export function getPackageInfo(cwd) {
+  const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
+  return fs.readJSONSync(packageJsonPath);
+}

package/bin/app/better/auth/(utils)/get-tsconfig-info.d.ts

@@ -0,0 +1,2 @@
+export declare function stripJsonComments(jsonString: string): string;
+export declare function getTsconfigInfo(cwd?: string, flatPath?: string): Promise<any>;

package/bin/app/better/auth/(utils)/get-tsconfig-info.js

@@ -0,0 +1,15 @@
+import fs from "@reliverse/relifso";
+import path from "path";
+export function stripJsonComments(jsonString) {
+  return jsonString.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
+}
+export async function getTsconfigInfo(cwd, flatPath) {
+  let tsConfigPath;
+  if (flatPath) {
+    tsConfigPath = flatPath;
+  } else {
+    tsConfigPath = cwd ? path.join(cwd, "tsconfig.json") : path.join("tsconfig.json");
+  }
+  const text = await fs.readFile(tsConfigPath, "utf-8");
+  return JSON.parse(stripJsonComments(text));
+}

package/bin/app/better/auth/(utils)/install-dependencies.d.ts

@@ -0,0 +1,5 @@
+export declare function installDependencies({ dependencies, packageManager, cwd, }: {
+    dependencies: string[];
+    packageManager: "npm" | "pnpm" | "bun" | "yarn";
+    cwd: string;
+}): Promise<boolean>;

package/bin/app/better/auth/(utils)/install-dependencies.js

@@ -0,0 +1,34 @@
+import { exec } from "child_process";
+export function installDependencies({
+  dependencies,
+  packageManager,
+  cwd
+}) {
+  let installCommand;
+  switch (packageManager) {
+    case "npm":
+      installCommand = "npm install --force";
+      break;
+    case "pnpm":
+      installCommand = "pnpm install";
+      break;
+    case "bun":
+      installCommand = "bun install";
+      break;
+    case "yarn":
+      installCommand = "yarn install";
+      break;
+    default:
+      throw new Error("Invalid package manager");
+  }
+  const command = `${installCommand} ${dependencies.join(" ")}`;
+  return new Promise((resolve, reject) => {
+    exec(command, { cwd }, (error, _stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr));
+        return;
+      }
+      resolve(true);
+    });
+  });
+}

package/bin/app/better/auth/cmd.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    config: {
+        type: "string";
+        default: string;
+        required: true;
+    };
+    schema: {
+        type: "string";
+        default: string;
+        required: true;
+    };
+}>;
+export default _default;