create-croissant 0.1.7 → 0.1.9

package/template/apps/web/node_modules/@better-auth/core/src/db/adapter/utils.ts

@@ -1,61 +0,0 @@
-import type { DBFieldAttribute } from "../type";
-
-export function withApplyDefault(
-	value: any,
-	field: DBFieldAttribute,
-	action: "create" | "update" | "findOne" | "findMany",
-) {
-	if (action === "update") {
-		// Apply onUpdate if value is undefined
-		if (value === undefined && field.onUpdate !== undefined) {
-			if (typeof field.onUpdate === "function") {
-				return field.onUpdate();
-			}
-			return field.onUpdate;
-		}
-		return value;
-	}
-	if (action === "create") {
-		// we do not want to apply default values if the value is null & not required
-		if (value === undefined || (field.required === true && value === null)) {
-			if (field.defaultValue !== undefined) {
-				if (typeof field.defaultValue === "function") {
-					return field.defaultValue();
-				}
-				return field.defaultValue;
-			}
-		}
-	}
-	return value;
-}
-
-function isObject(item: unknown): item is Record<string, unknown> {
-	return item !== null && typeof item === "object" && !Array.isArray(item);
-}
-
-export function deepmerge<T>(target: T, source: Partial<T>): T {
-	if (Array.isArray(target) && Array.isArray(source)) {
-		// merge arrays by concatenation
-		return [...target, ...source] as T;
-	} else if (isObject(target) && isObject(source)) {
-		const result: Record<string, unknown> = { ...target };
-
-		for (const [key, value] of Object.entries(source)) {
-			if (value === undefined) continue; // skip undefined
-
-			if (key in target) {
-				result[key] = deepmerge(
-					(target as Record<string, unknown>)[key],
-					value as unknown as Partial<T>,
-				);
-			} else {
-				result[key] = value;
-			}
-		}
-
-		return result as T;
-	}
-
-	// primitives and fallback: source overrides target
-	return source as T;
-}

package/template/apps/web/node_modules/@better-auth/core/src/db/get-tables.ts

@@ -1,296 +0,0 @@
-import type { BetterAuthOptions } from "../types";
-import type { BetterAuthDBSchema, DBFieldAttribute } from "./type";
-
-export const getAuthTables = (
-	options: BetterAuthOptions,
-): BetterAuthDBSchema => {
-	const pluginSchema = (options.plugins ?? []).reduce(
-		(acc, plugin) => {
-			const schema = plugin.schema;
-			if (!schema) return acc;
-			for (const [key, value] of Object.entries(schema)) {
-				acc[key] = {
-					fields: {
-						...acc[key]?.fields,
-						...value.fields,
-					},
-					modelName: value.modelName || key,
-				};
-			}
-			return acc;
-		},
-		{} as Record<
-			string,
-			{ fields: Record<string, DBFieldAttribute>; modelName: string }
-		>,
-	);
-
-	const shouldAddRateLimitTable = options.rateLimit?.storage === "database";
-	const rateLimitTable = {
-		rateLimit: {
-			modelName: options.rateLimit?.modelName || "rateLimit",
-			fields: {
-				key: {
-					type: "string",
-					unique: true,
-					required: true,
-					fieldName: options.rateLimit?.fields?.key || "key",
-				},
-				count: {
-					type: "number",
-					required: true,
-					fieldName: options.rateLimit?.fields?.count || "count",
-				},
-				lastRequest: {
-					type: "number",
-					bigint: true,
-					required: true,
-					fieldName: options.rateLimit?.fields?.lastRequest || "lastRequest",
-					defaultValue: () => Date.now(),
-				},
-			},
-		},
-	} satisfies BetterAuthDBSchema;
-
-	const { user, session, account, verification, ...pluginTables } =
-		pluginSchema;
-
-	const verificationTable = {
-		verification: {
-			modelName: options.verification?.modelName || "verification",
-			fields: {
-				identifier: {
-					type: "string",
-					required: true,
-					fieldName: options.verification?.fields?.identifier || "identifier",
-					index: true,
-				},
-				value: {
-					type: "string",
-					required: true,
-					fieldName: options.verification?.fields?.value || "value",
-				},
-				expiresAt: {
-					type: "date",
-					required: true,
-					fieldName: options.verification?.fields?.expiresAt || "expiresAt",
-				},
-				createdAt: {
-					type: "date",
-					required: true,
-					defaultValue: () => new Date(),
-					fieldName: options.verification?.fields?.createdAt || "createdAt",
-				},
-				updatedAt: {
-					type: "date",
-					required: true,
-					defaultValue: () => new Date(),
-					onUpdate: () => new Date(),
-					fieldName: options.verification?.fields?.updatedAt || "updatedAt",
-				},
-				...verification?.fields,
-				...options.verification?.additionalFields,
-			},
-			order: 4,
-		},
-	} satisfies BetterAuthDBSchema;
-
-	const sessionTable = {
-		session: {
-			modelName: options.session?.modelName || "session",
-			fields: {
-				expiresAt: {
-					type: "date",
-					required: true,
-					fieldName: options.session?.fields?.expiresAt || "expiresAt",
-				},
-				token: {
-					type: "string",
-					required: true,
-					fieldName: options.session?.fields?.token || "token",
-					unique: true,
-				},
-				createdAt: {
-					type: "date",
-					required: true,
-					fieldName: options.session?.fields?.createdAt || "createdAt",
-					defaultValue: () => new Date(),
-				},
-				updatedAt: {
-					type: "date",
-					required: true,
-					fieldName: options.session?.fields?.updatedAt || "updatedAt",
-					onUpdate: () => new Date(),
-				},
-				ipAddress: {
-					type: "string",
-					required: false,
-					fieldName: options.session?.fields?.ipAddress || "ipAddress",
-				},
-				userAgent: {
-					type: "string",
-					required: false,
-					fieldName: options.session?.fields?.userAgent || "userAgent",
-				},
-				userId: {
-					type: "string",
-					fieldName: options.session?.fields?.userId || "userId",
-					references: {
-						model: options.user?.modelName || "user",
-						field: "id",
-						onDelete: "cascade",
-					},
-					required: true,
-					index: true,
-				},
-				...session?.fields,
-				...options.session?.additionalFields,
-			},
-			order: 2,
-		},
-	} satisfies BetterAuthDBSchema;
-
-	return {
-		user: {
-			modelName: options.user?.modelName || "user",
-			fields: {
-				name: {
-					type: "string",
-					required: true,
-					fieldName: options.user?.fields?.name || "name",
-					sortable: true,
-				},
-				email: {
-					type: "string",
-					unique: true,
-					required: true,
-					fieldName: options.user?.fields?.email || "email",
-					sortable: true,
-				},
-				emailVerified: {
-					type: "boolean",
-					defaultValue: false,
-					required: true,
-					fieldName: options.user?.fields?.emailVerified || "emailVerified",
-					input: false,
-				},
-				image: {
-					type: "string",
-					required: false,
-					fieldName: options.user?.fields?.image || "image",
-				},
-				createdAt: {
-					type: "date",
-					defaultValue: () => new Date(),
-					required: true,
-					fieldName: options.user?.fields?.createdAt || "createdAt",
-				},
-				updatedAt: {
-					type: "date",
-					defaultValue: () => new Date(),
-					onUpdate: () => new Date(),
-					required: true,
-					fieldName: options.user?.fields?.updatedAt || "updatedAt",
-				},
-				...user?.fields,
-				...options.user?.additionalFields,
-			},
-			order: 1,
-		},
-		//only add session table if it's not stored in secondary storage
-		...(!options.secondaryStorage || options.session?.storeSessionInDatabase
-			? sessionTable
-			: {}),
-		account: {
-			modelName: options.account?.modelName || "account",
-			fields: {
-				accountId: {
-					type: "string",
-					required: true,
-					fieldName: options.account?.fields?.accountId || "accountId",
-				},
-				providerId: {
-					type: "string",
-					required: true,
-					fieldName: options.account?.fields?.providerId || "providerId",
-				},
-				userId: {
-					type: "string",
-					references: {
-						model: options.user?.modelName || "user",
-						field: "id",
-						onDelete: "cascade",
-					},
-					required: true,
-					fieldName: options.account?.fields?.userId || "userId",
-					index: true,
-				},
-				accessToken: {
-					type: "string",
-					required: false,
-					returned: false,
-					fieldName: options.account?.fields?.accessToken || "accessToken",
-				},
-				refreshToken: {
-					type: "string",
-					required: false,
-					returned: false,
-					fieldName: options.account?.fields?.refreshToken || "refreshToken",
-				},
-				idToken: {
-					type: "string",
-					required: false,
-					returned: false,
-					fieldName: options.account?.fields?.idToken || "idToken",
-				},
-				accessTokenExpiresAt: {
-					type: "date",
-					required: false,
-					returned: false,
-					fieldName:
-						options.account?.fields?.accessTokenExpiresAt ||
-						"accessTokenExpiresAt",
-				},
-				refreshTokenExpiresAt: {
-					type: "date",
-					required: false,
-					returned: false,
-					fieldName:
-						options.account?.fields?.refreshTokenExpiresAt ||
-						"refreshTokenExpiresAt",
-				},
-				scope: {
-					type: "string",
-					required: false,
-					fieldName: options.account?.fields?.scope || "scope",
-				},
-				password: {
-					type: "string",
-					required: false,
-					returned: false,
-					fieldName: options.account?.fields?.password || "password",
-				},
-				createdAt: {
-					type: "date",
-					required: true,
-					fieldName: options.account?.fields?.createdAt || "createdAt",
-					defaultValue: () => new Date(),
-				},
-				updatedAt: {
-					type: "date",
-					required: true,
-					fieldName: options.account?.fields?.updatedAt || "updatedAt",
-					onUpdate: () => new Date(),
-				},
-				...account?.fields,
-				...options.account?.additionalFields,
-			},
-			order: 3,
-		},
-		...(!options.secondaryStorage || options.verification?.storeInDatabase
-			? verificationTable
-			: {}),
-		...pluginTables,
-		...(shouldAddRateLimitTable ? rateLimitTable : {}),
-	} satisfies BetterAuthDBSchema;
-};

package/template/apps/web/node_modules/@better-auth/core/src/db/index.ts

@@ -1,43 +0,0 @@
-export { getAuthTables } from "./get-tables";
-export type { BetterAuthPluginDBSchema } from "./plugin";
-export {
-	type Account,
-	accountSchema,
-	type BaseAccount,
-} from "./schema/account";
-export {
-	type BaseRateLimit,
-	type RateLimit,
-	rateLimitSchema,
-} from "./schema/rate-limit";
-export {
-	type BaseSession,
-	type Session,
-	sessionSchema,
-} from "./schema/session";
-export { coreSchema } from "./schema/shared";
-export { type BaseUser, type User, userSchema } from "./schema/user";
-export {
-	type BaseVerification,
-	type Verification,
-	verificationSchema,
-} from "./schema/verification";
-export type {
-	BaseModelNames,
-	BetterAuthDBSchema,
-	DBFieldAttribute,
-	DBFieldAttributeConfig,
-	DBFieldType,
-	DBPrimitive,
-	InferDBFieldInput,
-	InferDBFieldOutput,
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromOptionsInput,
-	InferDBFieldsFromPlugins,
-	InferDBFieldsFromPluginsInput,
-	InferDBFieldsInput,
-	InferDBFieldsOutput,
-	InferDBValueType,
-	ModelNames,
-	SecondaryStorage,
-} from "./type";

package/template/apps/web/node_modules/@better-auth/core/src/db/plugin.ts

@@ -1,11 +0,0 @@
-import type { DBFieldAttribute } from "./type";
-
-export type BetterAuthPluginDBSchema = {
-	[table in string]: {
-		fields: {
-			[field: string]: DBFieldAttribute;
-		};
-		disableMigration?: boolean | undefined;
-		modelName?: string | undefined;
-	};
-};

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/account.ts

@@ -1,47 +0,0 @@
-import * as z from "zod";
-import type { Prettify } from "../../types";
-import type { BetterAuthOptions } from "../../types/init-options";
-import type {
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromPlugins,
-} from "../type";
-import { coreSchema } from "./shared";
-
-export const accountSchema = coreSchema.extend({
-	providerId: z.string(),
-	accountId: z.string(),
-	userId: z.coerce.string(),
-	accessToken: z.string().nullish(),
-	refreshToken: z.string().nullish(),
-	idToken: z.string().nullish(),
-	/**
-	 * Access token expires at
-	 */
-	accessTokenExpiresAt: z.date().nullish(),
-	/**
-	 * Refresh token expires at
-	 */
-	refreshTokenExpiresAt: z.date().nullish(),
-	/**
-	 * The scopes that the user has authorized
-	 */
-	scope: z.string().nullish(),
-	/**
-	 * Password is only stored in the credential provider
-	 */
-	password: z.string().nullish(),
-});
-
-export type BaseAccount = z.infer<typeof accountSchema>;
-
-/**
- * Account schema type used by better-auth, note that it's possible that account could have additional fields
- */
-export type Account<
-	DBOptions extends BetterAuthOptions["account"] = BetterAuthOptions["account"],
-	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
-> = Prettify<
-	BaseAccount &
-		InferDBFieldsFromOptions<DBOptions> &
-		InferDBFieldsFromPlugins<"account", Plugins>
->;

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/rate-limit.ts

@@ -1,36 +0,0 @@
-import * as z from "zod";
-import type { BetterAuthOptions, Prettify } from "../../types";
-import type {
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromPlugins,
-} from "../type";
-
-export const rateLimitSchema = z.object({
-	/**
-	 * The key to use for rate limiting
-	 */
-	key: z.string(),
-	/**
-	 * The number of requests made
-	 */
-	count: z.number(),
-	/**
-	 * The last request time in milliseconds
-	 */
-	lastRequest: z.number(),
-});
-
-export type BaseRateLimit = z.infer<typeof rateLimitSchema>;
-
-/**
- * Rate limit schema type used by better-auth for rate limiting
- */
-export type RateLimit<
-	DBOptions extends
-		BetterAuthOptions["rateLimit"] = BetterAuthOptions["rateLimit"],
-	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
-> = Prettify<
-	BaseRateLimit &
-		InferDBFieldsFromOptions<DBOptions> &
-		InferDBFieldsFromPlugins<"rateLimit", Plugins>
->;

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/session.ts

@@ -1,29 +0,0 @@
-import * as z from "zod";
-import type { BetterAuthOptions, Prettify } from "../../types";
-import type {
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromPlugins,
-} from "../type";
-import { coreSchema } from "./shared";
-
-export const sessionSchema = coreSchema.extend({
-	userId: z.coerce.string(),
-	expiresAt: z.date(),
-	token: z.string(),
-	ipAddress: z.string().nullish(),
-	userAgent: z.string().nullish(),
-});
-
-export type BaseSession = z.infer<typeof sessionSchema>;
-
-/**
- * Session schema type used by better-auth, note that it's possible that session could have additional fields
- */
-export type Session<
-	DBOptions extends BetterAuthOptions["session"] = BetterAuthOptions["session"],
-	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
-> = Prettify<
-	z.infer<typeof sessionSchema> &
-		InferDBFieldsFromOptions<DBOptions> &
-		InferDBFieldsFromPlugins<"session", Plugins>
->;

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/shared.ts

@@ -1,7 +0,0 @@
-import * as z from "zod";
-
-export const coreSchema = z.object({
-	id: z.string(),
-	createdAt: z.date().default(() => new Date()),
-	updatedAt: z.date().default(() => new Date()),
-});

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/user.ts

@@ -1,28 +0,0 @@
-import * as z from "zod";
-import type { BetterAuthOptions, Prettify } from "../../types";
-import type {
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromPlugins,
-} from "../type";
-import { coreSchema } from "./shared";
-
-export const userSchema = coreSchema.extend({
-	email: z.string().transform((val) => val.toLowerCase()),
-	emailVerified: z.boolean().default(false),
-	name: z.string(),
-	image: z.string().nullish(),
-});
-
-export type BaseUser = z.infer<typeof userSchema>;
-
-/**
- * User schema type used by better-auth, note that it's possible that user could have additional fields
- */
-export type User<
-	DBOptions extends BetterAuthOptions["user"] = BetterAuthOptions["user"],
-	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
-> = Prettify<
-	BaseUser &
-		InferDBFieldsFromOptions<DBOptions> &
-		InferDBFieldsFromPlugins<"user", Plugins>
->;

package/template/apps/web/node_modules/@better-auth/core/src/db/schema/verification.ts

@@ -1,28 +0,0 @@
-import * as z from "zod";
-import type { BetterAuthOptions, Prettify } from "../../types";
-import type {
-	InferDBFieldsFromOptions,
-	InferDBFieldsFromPlugins,
-} from "../type";
-import { coreSchema } from "./shared";
-
-export const verificationSchema = coreSchema.extend({
-	value: z.string(),
-	expiresAt: z.date(),
-	identifier: z.string(),
-});
-
-export type BaseVerification = z.infer<typeof verificationSchema>;
-
-/**
- * Verification schema type used by better-auth, note that it's possible that verification could have additional fields
- */
-export type Verification<
-	DBOptions extends
-		BetterAuthOptions["verification"] = BetterAuthOptions["verification"],
-	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
-> = Prettify<
-	BaseVerification &
-		InferDBFieldsFromOptions<DBOptions> &
-		InferDBFieldsFromPlugins<"verification", Plugins>
->;