@gatwech/core 0.0.1-beta.1

package/src/context/request-state.ts

@@ -0,0 +1,75 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import z from "zod";
+import { type AsyncLocalStorage, getAsyncLocalStorage } from "../async_hooks";
+
+export type RequestStateWeakMap = WeakMap<StandardSchemaV1, any>;
+
+let requestStateAsyncStorage: AsyncLocalStorage<RequestStateWeakMap> | null =
+	null;
+
+const ensureAsyncStorage = async () => {
+	if (!requestStateAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		requestStateAsyncStorage = new AsyncLocalStorage();
+	}
+	return requestStateAsyncStorage;
+};
+
+export async function getRequestStateAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+
+export async function hasRequestState() {
+	const als = await ensureAsyncStorage();
+	return als.getStore() !== undefined;
+}
+
+export async function getCurrentRequestState(): Promise<RequestStateWeakMap> {
+	const als = await ensureAsyncStorage();
+	const store = als.getStore();
+	if (!store) {
+		throw new Error(
+			"No request state found. Please make sure you are calling this function within a `runWithRequestState` callback.",
+		);
+	}
+	return store;
+}
+
+export async function runWithRequestState<T>(
+	store: RequestStateWeakMap,
+	fn: () => T,
+): Promise<T> {
+	const als = await ensureAsyncStorage();
+	return als.run(store, fn);
+}
+
+export interface RequestState<T> {
+	get<S>(): Promise<S & T>;
+	set(value: T): Promise<void>;
+}
+
+export function defineRequestState<T>(
+	schema?: StandardSchemaV1<T>,
+): RequestState<T>;
+export function defineRequestState<Schema extends StandardSchemaV1>(
+	schema?: Schema,
+): RequestState<StandardSchemaV1.InferInput<Schema>>;
+export function defineRequestState(
+	schema: StandardSchemaV1 = z.any(),
+): RequestState<any> {
+	return {
+		async get() {
+			const store = await getCurrentRequestState();
+			return store.get(schema);
+		},
+
+		async set(value) {
+			const store = await getCurrentRequestState();
+			const parsedValue = await schema["~standard"].validate(value);
+			if (parsedValue.issues) {
+				throw new Error(`Invalid value: ${JSON.stringify(parsedValue.issues)}`);
+			}
+			store.set(schema, parsedValue.value);
+		},
+	};
+}

package/src/context/transaction.ts

@@ -0,0 +1,72 @@
+import { type AsyncLocalStorage, getAsyncLocalStorage } from "../async_hooks";
+import type { DBAdapter, DBTransactionAdapter } from "../db/adapter";
+
+let currentAdapterAsyncStorage: AsyncLocalStorage<DBTransactionAdapter> | null =
+	null;
+
+const ensureAsyncStorage = async () => {
+	if (!currentAdapterAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		currentAdapterAsyncStorage = new AsyncLocalStorage();
+	}
+	return currentAdapterAsyncStorage;
+};
+
+/**
+ * This is for internal use only. Most users should use `getCurrentAdapter` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+export const getCurrentDBAdapterAsyncLocalStorage = async () => {
+	return ensureAsyncStorage();
+};
+
+export const getCurrentAdapter = async (
+	fallback: DBTransactionAdapter,
+): Promise<DBTransactionAdapter> => {
+	return ensureAsyncStorage()
+		.then((als) => {
+			return als.getStore() || fallback;
+		})
+		.catch(() => {
+			return fallback;
+		});
+};
+
+export const runWithAdapter = async <R>(
+	adapter: DBAdapter,
+	fn: () => R,
+): Promise<R> => {
+	let called = true;
+	return ensureAsyncStorage()
+		.then((als) => {
+			called = true;
+			return als.run(adapter, fn);
+		})
+		.catch((err) => {
+			if (!called) {
+				return fn();
+			}
+			throw err;
+		});
+};
+
+export const runWithTransaction = async <R>(
+	adapter: DBAdapter,
+	fn: () => R,
+): Promise<R> => {
+	let called = true;
+	return ensureAsyncStorage()
+		.then((als) => {
+			called = true;
+			return adapter.transaction(async (trx) => {
+				return als.run(trx, fn);
+			});
+		})
+		.catch((err) => {
+			if (!called) {
+				return fn();
+			}
+			throw err;
+		});
+};

package/src/db/adapter/index.ts

@@ -0,0 +1,466 @@
+import type { PayvoAuthOptions } from "../../types";
+import type { PayvoAuthDBSchema, DBFieldAttribute } from "../type";
+
+export type DBAdapterDebugLogOption =
+  | boolean
+  | {
+      /**
+       * Useful when you want to log only certain conditions.
+       */
+      logCondition?: (() => boolean) | undefined;
+      create?: boolean | undefined;
+      update?: boolean | undefined;
+      updateMany?: boolean | undefined;
+      findOne?: boolean | undefined;
+      findMany?: boolean | undefined;
+      delete?: boolean | undefined;
+      deleteMany?: boolean | undefined;
+      count?: boolean | undefined;
+    }
+  | {
+      /**
+       * Only used for adapter tests to show debug logs if a test fails.
+       *
+       * @deprecated Not actually deprecated. Doing this for IDEs to show this option at the very bottom and stop end-users from using this.
+       */
+      isRunningAdapterTests: boolean;
+    };
+
+export type DBAdapterSchemaCreation = {
+  /**
+   * Code to be inserted into the file
+   */
+  code: string;
+  /**
+   * Path to the file, including the file name and extension.
+   * Relative paths are supported, with the current working directory of the developer's project as the base.
+   */
+  path: string;
+  /**
+   * Append the file if it already exists.
+   * Note: This will not apply if `overwrite` is set to true.
+   */
+  append?: boolean | undefined;
+  /**
+   * Overwrite the file if it already exists
+   */
+  overwrite?: boolean | undefined;
+};
+
+export interface DBAdapterFactoryConfig<
+  Options extends PayvoAuthOptions = PayvoAuthOptions,
+> {
+  /**
+   * Use plural table names.
+   *
+   * All tables will be named with an `s` at the end.
+   *
+   * @default false
+   */
+  usePlural?: boolean | undefined;
+  /**
+   * Enable debug logs.
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * Name of the adapter.
+   *
+   * This is used to identify the adapter in the debug logs.
+   *
+   * @default `adapterId`
+   */
+  adapterName?: string | undefined;
+  /**
+   * Adapter id
+   */
+  adapterId: string;
+  /**
+   * If the database supports numeric ids, set this to `true`.
+   *
+   * @default true
+   */
+  supportsNumericIds?: boolean | undefined;
+  /**
+   * If the database doesn't support JSON columns, set this to `false`.
+   *
+   * We will handle the translation between using `JSON` columns, and saving `string`s to the database.
+   *
+   * @default false
+   */
+  supportsJSON?: boolean | undefined;
+  /**
+   * If the database doesn't support dates, set this to `false`.
+   *
+   * We will handle the translation between using `Date` objects, and saving `string`s to the database.
+   *
+   * @default true
+   */
+  supportsDates?: boolean | undefined;
+  /**
+   * If the database doesn't support booleans, set this to `false`.
+   *
+   * We will handle the translation between using `boolean`s, and saving `0`s and `1`s to the database.
+   *
+   * @default true
+   */
+  supportsBooleans?: boolean | undefined;
+  /**
+   * Execute multiple operations in a transaction.
+   *
+   * If the database doesn't support transactions, set this to `false` and operations will be executed sequentially.
+   *
+   * @default false
+   */
+  transaction?:
+    | (
+        | false
+        | (<R>(
+            callback: (trx: DBTransactionAdapter<Options>) => Promise<R>
+          ) => Promise<R>)
+      )
+    | undefined;
+  /**
+   * Disable id generation for the `create` method.
+   *
+   * This is useful for databases that don't support custom id values and would auto-generate them for you.
+   *
+   * @default false
+   */
+  disableIdGeneration?: boolean | undefined;
+  /**
+   * Map the keys of the input data.
+   *
+   * This is useful for databases that expect a different key name for a given situation.
+   *
+   * For example, MongoDB uses `_id` while in Better-Auth we use `id`.
+   *
+   *
+   * @example
+   * Each key represents the old key to replace.
+   * The value represents the new key
+   *
+   * This can be a partial object that only transforms some keys.
+   *
+   * ```ts
+   * mapKeysTransformInput: {
+   *  id: "_id" // We want to replace `id` to `_id` to save into MongoDB
+   * }
+   * ```
+   */
+  mapKeysTransformInput?: Record<string, string> | undefined;
+  /**
+   * Map the keys of the output data.
+   *
+   * This is useful for databases that expect a different key name for a given situation.
+   *
+   * For example, MongoDB uses `_id` while in Better-Auth we use `id`.
+   *
+   * @example
+   * Each key represents the old key to replace.
+   * The value represents the new key
+   *
+   * This can be a partial object that only transforms some keys.
+   *
+   * ```ts
+   * mapKeysTransformOutput: {
+   *  _id: "id" // In MongoDB, we save `id` as `_id`. So we want to replace `_id` with `id` when we get the data back.
+   * }
+   * ```
+   */
+  mapKeysTransformOutput?: Record<string, string> | undefined;
+  /**
+   * Custom transform input function.
+   *
+   * This function is used to transform the input data before it is saved to the database.
+   */
+  customTransformInput?:
+    | ((props: {
+        data: any;
+        /**
+         * The fields of the model.
+         */
+        fieldAttributes: DBFieldAttribute;
+        /**
+         * The field to transform.
+         */
+        field: string;
+        /**
+         * The action which was called from the adapter.
+         */
+        action: "create" | "update";
+        /**
+         * The model name.
+         */
+        model: string;
+        /**
+         * The schema of the user's Better-Auth instance.
+         */
+        schema: PayvoAuthDBSchema;
+        /**
+         * The options of the user's Better-Auth instance.
+         */
+        options: Options;
+      }) => any)
+    | undefined;
+  /**
+   * Custom transform output function.
+   *
+   * This function is used to transform the output data before it is returned to the user.
+   */
+  customTransformOutput?:
+    | ((props: {
+        data: any;
+        /**
+         * The fields of the model.
+         */
+        fieldAttributes: DBFieldAttribute;
+        /**
+         * The field to transform.
+         */
+        field: string;
+        /**
+         * The fields to select.
+         */
+        select: string[];
+        /**
+         * The model name.
+         */
+        model: string;
+        /**
+         * The schema of the user's Better-Auth instance.
+         */
+        schema: PayvoAuthDBSchema;
+        /**
+         * The options of the user's Better-Auth instance.
+         */
+        options: Options;
+      }) => any)
+    | undefined;
+  /**
+   * Custom ID generator function.
+   *
+   * By default, we can handle ID generation for you, however if the database your adapter is for only supports a specific custom id generation,
+   * then you can use this function to generate your own IDs.
+   *
+   *
+   * Notes:
+   * - If the user enabled `useNumberId`, then this option will be ignored. Unless this adapter config has `supportsNumericIds` set to `false`.
+   * - If `generateId` is `false` in the user's Better-Auth config, then this option will be ignored.
+   * - If `generateId` is a function, then it will override this option.
+   *
+   * @example
+   *
+   * ```ts
+   * customIdGenerator: ({ model }) => {
+   *  return "my-super-unique-id";
+   * }
+   * ```
+   */
+  customIdGenerator?: ((props: { model: string }) => string) | undefined;
+  /**
+   * Whether to disable the transform output.
+   * Do not use this option unless you know what you are doing.
+   * @default false
+   */
+  disableTransformOutput?: boolean | undefined;
+  /**
+   * Whether to disable the transform input.
+   * Do not use this option unless you know what you are doing.
+   * @default false
+   */
+  disableTransformInput?: boolean | undefined;
+}
+
+export type Where = {
+  /**
+   * @default eq
+   */
+  operator?:
+    | (
+        | "eq"
+        | "ne"
+        | "lt"
+        | "lte"
+        | "gt"
+        | "gte"
+        | "in"
+        | "not_in"
+        | "contains"
+        | "starts_with"
+        | "ends_with"
+      )
+    | undefined;
+  value: string | number | boolean | string[] | number[] | Date | null;
+  field: string;
+  /**
+   * @default AND
+   */
+  connector?: ("AND" | "OR") | undefined;
+};
+
+export type DBTransactionAdapter<
+  Options extends PayvoAuthOptions = PayvoAuthOptions,
+> = Omit<DBAdapter<Options>, "transaction">;
+
+export type DBAdapter<Options extends PayvoAuthOptions = PayvoAuthOptions> = {
+  id: string;
+  create: <T extends Record<string, any>, R = T>(data: {
+    model: string;
+    data: Omit<T, "id">;
+    select?: string[] | undefined;
+    /**
+     * By default, any `id` provided in `data` will be ignored.
+     *
+     * If you want to force the `id` to be the same as the `data.id`, set this to `true`.
+     */
+    forceAllowId?: boolean | undefined;
+  }) => Promise<R>;
+  findOne: <T>(data: {
+    model: string;
+    where: Where[];
+    select?: string[] | undefined;
+  }) => Promise<T | null>;
+  findMany: <T>(data: {
+    model: string;
+    where?: Where[] | undefined;
+    limit?: number | undefined;
+    sortBy?:
+      | {
+          field: string;
+          direction: "asc" | "desc";
+        }
+      | undefined;
+    offset?: number | undefined;
+  }) => Promise<T[]>;
+  count: (data: {
+    model: string;
+    where?: Where[] | undefined;
+  }) => Promise<number>;
+  /**
+   * ⚠︎ Update may not return the updated data
+   * if multiple where clauses are provided
+   */
+  update: <T>(data: {
+    model: string;
+    where: Where[];
+    update: Record<string, any>;
+  }) => Promise<T | null>;
+  updateMany: (data: {
+    model: string;
+    where: Where[];
+    update: Record<string, any>;
+  }) => Promise<number>;
+  delete: <T>(data: { model: string; where: Where[] }) => Promise<void>;
+  deleteMany: (data: { model: string; where: Where[] }) => Promise<number>;
+  /**
+   * Execute multiple operations in a transaction.
+   * If the adapter doesn't support transactions, operations will be executed sequentially.
+   */
+  transaction: <R>(
+    callback: (trx: DBTransactionAdapter<Options>) => Promise<R>
+  ) => Promise<R>;
+  /**
+   *
+   * @param options
+   * @param file - file path if provided by the user
+   */
+  createSchema?:
+    | ((options: Options, file?: string) => Promise<DBAdapterSchemaCreation>)
+    | undefined;
+  options?:
+    | ({
+        adapterConfig: DBAdapterFactoryConfig<Options>;
+      } & CustomAdapter["options"])
+    | undefined;
+};
+
+export type CleanedWhere = Required<Where>;
+
+export interface CustomAdapter {
+  create: <T extends Record<string, any>>({
+    data,
+    model,
+    select,
+  }: {
+    model: string;
+    data: T;
+    select?: string[] | undefined;
+  }) => Promise<T>;
+  update: <T>(data: {
+    model: string;
+    where: CleanedWhere[];
+    update: T;
+  }) => Promise<T | null>;
+  updateMany: (data: {
+    model: string;
+    where: CleanedWhere[];
+    update: Record<string, any>;
+  }) => Promise<number>;
+  findOne: <T>({
+    model,
+    where,
+    select,
+  }: {
+    model: string;
+    where: CleanedWhere[];
+    select?: string[] | undefined;
+  }) => Promise<T | null>;
+  findMany: <T>({
+    model,
+    where,
+    limit,
+    sortBy,
+    offset,
+  }: {
+    model: string;
+    where?: CleanedWhere[] | undefined;
+    limit: number;
+    sortBy?: { field: string; direction: "asc" | "desc" } | undefined;
+    offset?: number | undefined;
+  }) => Promise<T[]>;
+  delete: ({
+    model,
+    where,
+  }: {
+    model: string;
+    where: CleanedWhere[];
+  }) => Promise<void>;
+  deleteMany: ({
+    model,
+    where,
+  }: {
+    model: string;
+    where: CleanedWhere[];
+  }) => Promise<number>;
+  count: ({
+    model,
+    where,
+  }: {
+    model: string;
+    where?: CleanedWhere[] | undefined;
+  }) => Promise<number>;
+  createSchema?:
+    | ((props: {
+        /**
+         * The file the user may have passed in to the `generate` command as the expected schema file output path.
+         */
+        file?: string;
+        /**
+         * The tables from the user's Better-Auth instance schema.
+         */
+        tables: PayvoAuthDBSchema;
+      }) => Promise<DBAdapterSchemaCreation>)
+    | undefined;
+  /**
+   * Your adapter's options.
+   */
+  options?: Record<string, any> | undefined;
+}
+
+export interface DBAdapterInstance<
+  Options extends PayvoAuthOptions = PayvoAuthOptions,
+> {
+  (options: PayvoAuthOptions): DBAdapter<Options>;
+}

package/src/db/index.ts

@@ -0,0 +1,50 @@
+import type { PayvoAuthPluginDBSchema } from "./plugin";
+import type {
+  PayvoAuthDBSchema,
+  DBFieldAttribute,
+  DBFieldAttributeConfig,
+  DBFieldType,
+  DBPrimitive,
+} from "./type";
+
+export type { PayvoAuthPluginDBSchema } from "./plugin";
+export { type Account, accountSchema } from "./schema/account";
+export { type RateLimit, rateLimitSchema } from "./schema/rate-limit";
+export { type Session, sessionSchema } from "./schema/session";
+export { coreSchema } from "./schema/shared";
+export { type User, userSchema } from "./schema/user";
+export { type Verification, verificationSchema } from "./schema/verification";
+export type {
+  PayvoAuthDBSchema,
+  DBFieldAttribute,
+  DBFieldAttributeConfig,
+  DBFieldType,
+  DBPreservedModels,
+  DBPrimitive,
+  SecondaryStorage,
+} from "./type";
+
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type AuthPluginSchema = PayvoAuthPluginDBSchema;
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type FieldAttribute = DBFieldAttribute;
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type FieldAttributeConfig = DBFieldAttributeConfig;
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type FieldType = DBFieldType;
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type Primitive = DBPrimitive;
+/**
+ * @deprecated Backport for 1.3.x, we will remove this in 1.4.x
+ */
+export type PayvoAuthDbSchema = PayvoAuthDBSchema;

package/src/db/plugin.ts

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

package/src/db/schema/account.ts

@@ -0,0 +1,34 @@
+import * as z from "zod";
+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(),
+});
+
+/**
+ * Account schema type used by payvo-auth, note that it's possible that account could have additional fields
+ *
+ * todo: we should use generics to extend this type with additional fields from plugins and options in the future
+ */
+export type Account = z.infer<typeof accountSchema>;