@better-auth/core 1.4.12-beta.2 → 1.4.13

package/dist/db/adapter/get-default-field-name.d.mts

@@ -0,0 +1,18 @@
+import { BetterAuthDBSchema } from "../type.mjs";
+
+//#region src/db/adapter/get-default-field-name.d.ts
+declare const initGetDefaultFieldName: ({
+  schema,
+  usePlural
+}: {
+  schema: BetterAuthDBSchema;
+  usePlural: boolean | undefined;
+}) => ({
+  field,
+  model: unsafeModel
+}: {
+  model: string;
+  field: string;
+}) => string;
+//#endregion
+export { initGetDefaultFieldName };

package/dist/db/adapter/get-default-field-name.mjs

@@ -0,0 +1,38 @@
+import { BetterAuthError } from "../../error/index.mjs";
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+
+//#region src/db/adapter/get-default-field-name.ts
+const initGetDefaultFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* This function helps us get the default field name from the schema defined by devs.
+	* Often times, the user will be using the `fieldName` which could had been customized by the users.
+	* This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom fieldName.
+	* 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+	*/
+	const getDefaultFieldName = ({ field, model: unsafeModel }) => {
+		if (field === "id" || field === "_id") return "id";
+		const model = getDefaultModelName(unsafeModel);
+		let f = schema[model]?.fields[field];
+		if (!f) {
+			const result = Object.entries(schema[model].fields).find(([_, f$1]) => f$1.fieldName === field);
+			if (result) {
+				f = result[1];
+				field = result[0];
+			}
+		}
+		if (!f) throw new BetterAuthError(`Field ${field} not found in model ${model}`);
+		return field;
+	};
+	return getDefaultFieldName;
+};
+
+//#endregion
+export { initGetDefaultFieldName };

package/dist/db/adapter/get-default-model-name.d.mts

@@ -0,0 +1,12 @@
+import { BetterAuthDBSchema } from "../type.mjs";
+
+//#region src/db/adapter/get-default-model-name.d.ts
+declare const initGetDefaultModelName: ({
+  usePlural,
+  schema
+}: {
+  usePlural: boolean | undefined;
+  schema: BetterAuthDBSchema;
+}) => (model: string) => string;
+//#endregion
+export { initGetDefaultModelName };

package/dist/db/adapter/get-default-model-name.mjs

@@ -0,0 +1,32 @@
+import { BetterAuthError } from "../../error/index.mjs";
+
+//#region src/db/adapter/get-default-model-name.ts
+const initGetDefaultModelName = ({ usePlural, schema }) => {
+	/**
+	* This function helps us get the default model name from the schema defined by devs.
+	* Often times, the user will be using the `modelName` which could had been customized by the users.
+	* This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom modelName.
+	* 2. When using a custom modelName, doing something like `schema[model]` will not work.
+	* 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+	*/
+	const getDefaultModelName = (model) => {
+		if (usePlural && model.charAt(model.length - 1) === "s") {
+			const pluralessModel = model.slice(0, -1);
+			let m$1 = schema[pluralessModel] ? pluralessModel : void 0;
+			if (!m$1) m$1 = Object.entries(schema).find(([_, f]) => f.modelName === pluralessModel)?.[0];
+			if (m$1) return m$1;
+		}
+		let m = schema[model] ? model : void 0;
+		if (!m) m = Object.entries(schema).find(([_, f]) => f.modelName === model)?.[0];
+		if (!m) throw new BetterAuthError(`Model "${model}" not found in schema`);
+		return m;
+	};
+	return getDefaultModelName;
+};
+
+//#endregion
+export { initGetDefaultModelName };

package/dist/db/adapter/get-field-attributes.d.mts

@@ -0,0 +1,29 @@
+import { BetterAuthDBSchema, DBFieldAttribute, DBFieldType } from "../type.mjs";
+import "../index.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
+
+//#region src/db/adapter/get-field-attributes.d.ts
+declare const initGetFieldAttributes: ({
+  usePlural,
+  schema,
+  options,
+  customIdGenerator,
+  disableIdGeneration
+}: {
+  usePlural?: boolean;
+  schema: BetterAuthDBSchema;
+  options: BetterAuthOptions;
+  disableIdGeneration?: boolean;
+  customIdGenerator?: ((props: {
+    model: string;
+  }) => string) | undefined;
+}) => ({
+  model,
+  field
+}: {
+  model: string;
+  field: string;
+}) => DBFieldAttribute<DBFieldType>;
+//#endregion
+export { initGetFieldAttributes };

package/dist/db/adapter/get-field-attributes.mjs

@@ -0,0 +1,39 @@
+import { BetterAuthError } from "../../error/index.mjs";
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+import { initGetDefaultFieldName } from "./get-default-field-name.mjs";
+import { initGetIdField } from "./get-id-field.mjs";
+
+//#region src/db/adapter/get-field-attributes.ts
+const initGetFieldAttributes = ({ usePlural, schema, options, customIdGenerator, disableIdGeneration }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural,
+		schema
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		usePlural,
+		schema
+	});
+	const idField = initGetIdField({
+		usePlural,
+		schema,
+		options,
+		customIdGenerator,
+		disableIdGeneration
+	});
+	const getFieldAttributes = ({ model, field }) => {
+		const defaultModelName = getDefaultModelName(model);
+		const defaultFieldName = getDefaultFieldName({
+			field,
+			model: defaultModelName
+		});
+		const fields = schema[defaultModelName].fields;
+		fields.id = idField({ customModelName: defaultModelName });
+		const fieldAttributes = fields[defaultFieldName];
+		if (!fieldAttributes) throw new BetterAuthError(`Field ${field} not found in model ${model}`);
+		return fieldAttributes;
+	};
+	return getFieldAttributes;
+};
+
+//#endregion
+export { initGetFieldAttributes };

package/dist/db/adapter/get-field-name.d.mts

@@ -0,0 +1,18 @@
+import { BetterAuthDBSchema } from "../type.mjs";
+
+//#region src/db/adapter/get-field-name.d.ts
+declare const initGetFieldName: ({
+  schema,
+  usePlural
+}: {
+  schema: BetterAuthDBSchema;
+  usePlural: boolean | undefined;
+}) => ({
+  model: modelName,
+  field: fieldName
+}: {
+  model: string;
+  field: string;
+}) => string;
+//#endregion
+export { initGetFieldName };

package/dist/db/adapter/get-field-name.mjs

@@ -0,0 +1,33 @@
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+import { initGetDefaultFieldName } from "./get-default-field-name.mjs";
+
+//#region src/db/adapter/get-field-name.ts
+const initGetFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		schema,
+		usePlural
+	});
+	/**
+	* Get the field name which is expected to be saved in the database based on the user's schema.
+	*
+	* This function is useful if you need to save the field name to the database.
+	*
+	* For example, if the user has defined a custom field name for the `user` model, then you can use this function to get the actual field name from the schema.
+	*/
+	function getFieldName({ model: modelName, field: fieldName }) {
+		const model = getDefaultModelName(modelName);
+		const field = getDefaultFieldName({
+			model,
+			field: fieldName
+		});
+		return schema[model]?.fields[field]?.fieldName || field;
+	}
+	return getFieldName;
+};
+
+//#endregion
+export { initGetFieldName };

package/dist/db/adapter/get-id-field.d.mts

@@ -0,0 +1,39 @@
+import { BetterAuthDBSchema, DBPrimitive } from "../type.mjs";
+import "../index.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
+
+//#region src/db/adapter/get-id-field.d.ts
+declare const initGetIdField: ({
+  usePlural,
+  schema,
+  disableIdGeneration,
+  options,
+  customIdGenerator,
+  supportsUUIDs
+}: {
+  usePlural?: boolean;
+  schema: BetterAuthDBSchema;
+  options: BetterAuthOptions;
+  disableIdGeneration?: boolean;
+  customIdGenerator?: ((props: {
+    model: string;
+  }) => string) | undefined;
+  supportsUUIDs?: boolean;
+}) => ({
+  customModelName,
+  forceAllowId
+}: {
+  customModelName?: string;
+  forceAllowId?: boolean;
+}) => {
+  transform: {
+    input: (value: DBPrimitive) => string | number | true | unknown[] | Date | Record<string, unknown> | undefined;
+    output: (value: DBPrimitive) => string | undefined;
+  };
+  defaultValue?: (() => string | false | undefined) | undefined;
+  type: "string" | "number";
+  required: boolean;
+};
+//#endregion
+export { initGetIdField };

package/dist/db/adapter/get-id-field.mjs

@@ -0,0 +1,68 @@
+import { logger } from "../../env/logger.mjs";
+import "../../env/index.mjs";
+import { generateId } from "../../utils/id.mjs";
+import "../../utils/index.mjs";
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+
+//#region src/db/adapter/get-id-field.ts
+const initGetIdField = ({ usePlural, schema, disableIdGeneration, options, customIdGenerator, supportsUUIDs }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural,
+		schema
+	});
+	const idField = ({ customModelName, forceAllowId }) => {
+		const useNumberId = options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial";
+		const useUUIDs = options.advanced?.database?.generateId === "uuid";
+		const shouldGenerateId = (() => {
+			if (disableIdGeneration) return false;
+			else if (useNumberId && !forceAllowId) return false;
+			else if (useUUIDs) return !supportsUUIDs;
+			else return true;
+		})();
+		const model = getDefaultModelName(customModelName ?? "id");
+		return {
+			type: useNumberId ? "number" : "string",
+			required: shouldGenerateId ? true : false,
+			...shouldGenerateId ? { defaultValue() {
+				if (disableIdGeneration) return void 0;
+				const generateId$1 = options.advanced?.database?.generateId;
+				if (generateId$1 === false || useNumberId) return void 0;
+				if (typeof generateId$1 === "function") return generateId$1({ model });
+				if (customIdGenerator) return customIdGenerator({ model });
+				if (generateId$1 === "uuid") return crypto.randomUUID();
+				return generateId();
+			} } : {},
+			transform: {
+				input: (value) => {
+					if (!value) return void 0;
+					if (useNumberId) {
+						const numberValue = Number(value);
+						if (isNaN(numberValue)) return;
+						return numberValue;
+					}
+					if (useUUIDs) {
+						if (shouldGenerateId && !forceAllowId) return value;
+						if (disableIdGeneration) return void 0;
+						if (supportsUUIDs) return void 0;
+						if (forceAllowId && typeof value === "string") if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) return value;
+						else {
+							const stack = (/* @__PURE__ */ new Error()).stack?.split("\n").filter((_, i) => i !== 1).join("\n").replace("Error:", "");
+							logger.warn("[Adapter Factory] - Invalid UUID value for field `id` provided when `forceAllowId` is true. Generating a new UUID.", stack);
+						}
+						if (typeof value !== "string" && !supportsUUIDs) return crypto.randomUUID();
+						return;
+					}
+					return value;
+				},
+				output: (value) => {
+					if (!value) return void 0;
+					return String(value);
+				}
+			}
+		};
+	};
+	return idField;
+};
+
+//#endregion
+export { initGetIdField };

package/dist/db/adapter/get-model-name.d.mts

@@ -0,0 +1,12 @@
+import { BetterAuthDBSchema } from "../type.mjs";
+
+//#region src/db/adapter/get-model-name.d.ts
+declare const initGetModelName: ({
+  usePlural,
+  schema
+}: {
+  usePlural: boolean | undefined;
+  schema: BetterAuthDBSchema;
+}) => (model: string) => string;
+//#endregion
+export { initGetModelName };

package/dist/db/adapter/get-model-name.mjs

@@ -0,0 +1,23 @@
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+
+//#region src/db/adapter/get-model-name.ts
+const initGetModelName = ({ usePlural, schema }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* Users can overwrite the default model of some tables. This function helps find the correct model name.
+	* Furthermore, if the user passes `usePlural` as true in their adapter config,
+	* then we should return the model name ending with an `s`.
+	*/
+	const getModelName = (model) => {
+		const defaultModelKey = getDefaultModelName(model);
+		if (schema && schema[defaultModelKey] && schema[defaultModelKey].modelName !== model) return usePlural ? `${schema[defaultModelKey].modelName}s` : schema[defaultModelKey].modelName;
+		return usePlural ? `${model}s` : model;
+	};
+	return getModelName;
+};
+
+//#endregion
+export { initGetModelName };