@gatwech/auth 1.0.0-beta.18

package/dist/src/client/types.d.ts

@@ -0,0 +1,49 @@
+import type { PayvoAuthClientOptions, PayvoAuthClientPlugin, PayvoAuthPlugin, ClientAtomListener, ClientStore } from "@gatwech/core";
+import type { Auth } from "../auth";
+import type { InferFieldsInputClient, InferFieldsOutput } from "../db";
+import type { Session, User } from "../types";
+import type { StripEmptyObjects, UnionToIntersection } from "../types/helper";
+import type { InferRoutes } from "./path-to-object";
+export type { ClientStore, ClientAtomListener, PayvoAuthClientOptions, PayvoAuthClientPlugin, };
+/**
+ * @deprecated use type `PayvoAuthClientOptions` instead.
+ */
+export type Store = ClientStore;
+/**
+ * @deprecated use type `ClientAtomListener` instead.
+ */
+export type AtomListener = ClientAtomListener;
+/**
+ * @deprecated use type `PayvoAuthClientPlugin` instead.
+ */
+export type ClientOptions = PayvoAuthClientOptions;
+export type InferClientAPI<O extends PayvoAuthClientOptions> = InferRoutes<O["plugins"] extends Array<any> ? Auth["api"] & (O["plugins"] extends Array<infer Pl> ? UnionToIntersection<Pl extends {
+    $InferServerPlugin: infer Plug;
+} ? Plug extends {
+    endpoints: infer Endpoints;
+} ? Endpoints : {} : {}> : {}) : Auth["api"], O>;
+export type InferActions<O extends PayvoAuthClientOptions> = (O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends PayvoAuthClientPlugin ? Plugin["getActions"] extends (...args: any) => infer Actions ? Actions : {} : {}> : {}) & InferRoutes<O["$InferAuth"] extends {
+    plugins: infer Plugins;
+} ? Plugins extends Array<infer Plugin> ? Plugin extends {
+    endpoints: infer Endpoints;
+} ? Endpoints : {} : {} : {}, O>;
+export type InferErrorCodes<O extends PayvoAuthClientOptions> = O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends PayvoAuthClientPlugin ? Plugin["$InferServerPlugin"] extends PayvoAuthPlugin ? Plugin["$InferServerPlugin"]["$ERROR_CODES"] : {} : {}> : {};
+/**
+ * signals are just used to recall a computed value.
+ * as a convention they start with "$"
+ */
+export type IsSignal<T> = T extends `$${infer _}` ? true : false;
+export type InferPluginsFromClient<O extends PayvoAuthClientOptions> = O["plugins"] extends Array<PayvoAuthClientPlugin> ? Array<O["plugins"][number]["$InferServerPlugin"]> : undefined;
+export type InferSessionFromClient<O extends PayvoAuthClientOptions> = StripEmptyObjects<Session & UnionToIntersection<InferAdditionalFromClient<O, "session", "output">>>;
+export type InferUserFromClient<O extends PayvoAuthClientOptions> = StripEmptyObjects<User & UnionToIntersection<InferAdditionalFromClient<O, "user", "output">>>;
+export type InferAdditionalFromClient<Options extends PayvoAuthClientOptions, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends Array<infer T> ? T extends PayvoAuthClientPlugin ? T["$InferServerPlugin"] extends {
+    schema: {
+        [key in Key]: {
+            fields: infer Field;
+        };
+    };
+} ? Format extends "input" ? InferFieldsInputClient<Field> : InferFieldsOutput<Field> : {} : {} : {};
+export type SessionQueryParams = {
+    disableCookieCache?: boolean | undefined;
+    disableRefresh?: boolean | undefined;
+};

package/dist/src/client/vanilla.d.ts

@@ -0,0 +1,124 @@
+import type { PayvoAuthClientOptions, PayvoAuthClientPlugin } from "@gatwech/core";
+import type { BASE_ERROR_CODES } from "@gatwech/core/error";
+import type { BetterFetchError } from "@better-fetch/fetch";
+import type { Atom } from "nanostores";
+import type { PrettifyDeep, UnionToIntersection } from "../types/helper";
+import type { InferActions, InferClientAPI, InferErrorCodes, IsSignal } from "./types";
+type InferResolvedHooks<O extends PayvoAuthClientOptions> = O extends {
+    plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends PayvoAuthClientPlugin ? Plugin["getAtoms"] extends (fetch: any) => infer Atoms ? Atoms extends Record<string, any> ? {
+    [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: Atoms[key];
+} : {} : {} : {}> : {};
+export declare function createAuthClient<Option extends PayvoAuthClientOptions>(options?: Option | undefined): UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+    useSession: Atom<{
+        data: InferClientAPI<Option> extends {
+            getSession: () => Promise<infer Res>;
+        } ? Res extends {
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | {
+            data: infer S;
+            error: null;
+        } ? S : Res extends Record<string, any> ? Res : never : never;
+        error: BetterFetchError | null;
+        isPending: boolean;
+    }>;
+    $fetch: import("@better-fetch/fetch").BetterFetch<{
+        plugins: (import("@better-fetch/fetch").BetterFetchPlugin | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onRequest<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
+                onError: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
+                onRequest: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
+                onResponse: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
+            };
+        })[];
+        method: string;
+        headers?: (HeadersInit & (HeadersInit | {
+            accept: "application/json" | "text/plain" | "application/octet-stream";
+            "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+            authorization: "Bearer" | "Basic";
+        })) | undefined;
+        redirect?: RequestRedirect | undefined;
+        cache?: RequestCache | undefined;
+        credentials?: RequestCredentials;
+        integrity?: string | undefined;
+        keepalive?: boolean | undefined;
+        mode?: RequestMode | undefined;
+        priority?: RequestPriority | undefined;
+        referrer?: string | undefined;
+        referrerPolicy?: ReferrerPolicy | undefined;
+        signal?: (AbortSignal | null) | undefined;
+        window?: null | undefined;
+        onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+        hookOptions?: {
+            cloneResponse?: boolean;
+        } | undefined;
+        timeout?: number | undefined;
+        customFetchImpl: import("@better-fetch/fetch").FetchEsque;
+        baseURL: string;
+        throw?: boolean | undefined;
+        auth?: ({
+            type: "Bearer";
+            token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+        } | {
+            type: "Basic";
+            username: string | (() => string | undefined) | undefined;
+            password: string | (() => string | undefined) | undefined;
+        } | {
+            type: "Custom";
+            prefix: string | (() => string | undefined) | undefined;
+            value: string | (() => string | undefined) | undefined;
+        }) | undefined;
+        body?: any;
+        query?: any;
+        params?: any;
+        duplex?: "full" | "half" | undefined;
+        jsonParser: (text: string) => Promise<any> | any;
+        retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+        retryAttempt?: number | undefined;
+        output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+        disableValidation?: boolean | undefined;
+    }, unknown, unknown, {}>;
+    $store: {
+        notify: (signal?: (Omit<string, "$sessionSignal"> | "$sessionSignal") | undefined) => void;
+        listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+        atoms: Record<string, import("nanostores").WritableAtom<any>>;
+    };
+    $Infer: {
+        Session: NonNullable<InferClientAPI<Option> extends {
+            getSession: () => Promise<infer Res>;
+        } ? Res extends {
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | {
+            data: infer S;
+            error: null;
+        } ? S : Res extends Record<string, any> ? Res : never : never>;
+    };
+    $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+export type AuthClient<Option extends PayvoAuthClientOptions> = ReturnType<typeof createAuthClient<Option>>;
+export {};

package/dist/src/cookies/check-cookies.d.ts

@@ -0,0 +1,4 @@
+import type { AuthContext } from "@gatwech/core";
+export declare const checkAuthCookie: (request: Request | Headers, auth: {
+    $context: Promise<AuthContext>;
+}) => Promise<string | null>;

package/dist/src/cookies/cookie-utils.d.ts

@@ -0,0 +1,16 @@
+interface CookieAttributes {
+    value: string;
+    "max-age"?: number | undefined;
+    expires?: Date | undefined;
+    domain?: string | undefined;
+    path?: string | undefined;
+    secure?: boolean | undefined;
+    httponly?: boolean | undefined;
+    samesite?: ("strict" | "lax" | "none") | undefined;
+    [key: string]: any;
+}
+export declare function parseSetCookieHeader(setCookie: string): Map<string, CookieAttributes>;
+export declare function setCookieToHeader(headers: Headers): (context: {
+    response: Response;
+}) => void;
+export {};

package/dist/src/cookies/index.d.ts

@@ -0,0 +1,56 @@
+import type { PayvoAuthCookies, PayvoAuthOptions, GenericEndpointContext } from "@gatwech/core";
+import type { CookieOptions } from "better-call";
+import type { Session, User } from "../types";
+export declare function createCookieGetter(options: PayvoAuthOptions): (cookieName: string, overrideAttributes?: Partial<CookieOptions>) => {
+    name: string;
+    attributes: CookieOptions;
+};
+export declare function getCookies(options: PayvoAuthOptions): {
+    sessionToken: {
+        name: string;
+        options: CookieOptions;
+    };
+    /**
+     * This cookie is used to store the session data in the cookie
+     * This is useful for when you want to cache the session in the cookie
+     */
+    sessionData: {
+        name: string;
+        options: CookieOptions;
+    };
+    dontRememberToken: {
+        name: string;
+        options: CookieOptions;
+    };
+};
+export declare function setCookieCache(ctx: GenericEndpointContext, session: {
+    session: Session & Record<string, any>;
+    user: User;
+}, dontRememberMe: boolean): Promise<void>;
+export declare function setSessionCookie(ctx: GenericEndpointContext, session: {
+    session: Session & Record<string, any>;
+    user: User;
+}, dontRememberMe?: boolean | undefined, overrides?: Partial<CookieOptions> | undefined): Promise<void>;
+export declare function deleteSessionCookie(ctx: GenericEndpointContext, skipDontRememberMe?: boolean | undefined): void;
+export declare function parseCookies(cookieHeader: string): Map<string, string>;
+export type EligibleCookies = (string & {}) | (keyof PayvoAuthCookies & {});
+export declare const getSessionCookie: (request: Request | Headers, config?: {
+    cookiePrefix?: string;
+    cookieName?: string;
+    path?: string;
+} | undefined) => string | null;
+export declare const getCookieCache: <S extends {
+    session: Session & Record<string, any>;
+    user: User & Record<string, any>;
+    updatedAt: number;
+    version?: string;
+}>(request: Request | Headers, config?: {
+    cookiePrefix?: string;
+    cookieName?: string;
+    isSecure?: boolean;
+    secret?: string;
+    strategy?: "compact" | "jwt" | "jwe";
+    version?: string | ((session: Session & Record<string, any>, user: User & Record<string, any>) => string) | ((session: Session & Record<string, any>, user: User & Record<string, any>) => Promise<string>);
+} | undefined) => Promise<S | null>;
+export * from "./cookie-utils";
+export { createSessionStore, getChunkedCookie } from "./session-store";

package/dist/src/cookies/session-store.d.ts

@@ -0,0 +1,43 @@
+import type { GenericEndpointContext } from "@gatwech/core";
+import type { CookieOptions } from "better-call";
+import * as z from "zod";
+interface Cookie {
+    name: string;
+    value: string;
+    options: CookieOptions;
+}
+/**
+ * Create a session store for handling cookie chunking.
+ * When session data exceeds 4KB, it automatically splits it into multiple cookies.
+ *
+ * Based on next-auth's SessionStore implementation.
+ * @see https://github.com/nextauthjs/next-auth/blob/27b2519b84b8eb9cf053775dea29d577d2aa0098/packages/next-auth/src/core/lib/cookie.ts
+ */
+export declare function createSessionStore(cookieName: string, cookieOptions: CookieOptions, ctx: GenericEndpointContext): {
+    /**
+     * Get the full session data by joining all chunks
+     */
+    getValue(): string;
+    /**
+     * Check if there are existing chunks
+     */
+    hasChunks(): boolean;
+    /**
+     * Chunk a cookie value and return all cookies to set (including cleanup cookies)
+     */
+    chunk(value: string, options?: Partial<CookieOptions>): Cookie[];
+    /**
+     * Get cookies to clean up all chunks
+     */
+    clean(): Cookie[];
+    /**
+     * Set all cookies in the context
+     */
+    setCookies(cookies: Cookie[]): void;
+};
+export declare function getChunkedCookie(ctx: GenericEndpointContext, cookieName: string): string | null;
+export declare const getSessionQuerySchema: z.ZodOptional<z.ZodObject<{
+    disableCookieCache: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    disableRefresh: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>>;
+export {};

package/dist/src/crypto/buffer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compare two buffers in constant time.
+ */
+export declare function constantTimeEqual(a: ArrayBuffer | Uint8Array, b: ArrayBuffer | Uint8Array): boolean;

package/dist/src/crypto/index.d.ts

@@ -0,0 +1,14 @@
+export type SymmetricEncryptOptions = {
+    key: string;
+    data: string;
+};
+export declare const symmetricEncrypt: ({ key, data, }: SymmetricEncryptOptions) => Promise<string>;
+export type SymmetricDecryptOptions = {
+    key: string;
+    data: string;
+};
+export declare const symmetricDecrypt: ({ key, data, }: SymmetricDecryptOptions) => Promise<string>;
+export * from "./buffer";
+export * from "./jwt";
+export * from "./password";
+export * from "./random";

package/dist/src/crypto/jwt.d.ts

@@ -0,0 +1,4 @@
+export declare function signJWT(payload: any, secret: string, expiresIn?: number): Promise<string>;
+export declare function verifyJWT<T = any>(token: string, secret: string): Promise<T | null>;
+export declare function symmetricEncodeJWT<T extends Record<string, any>>(payload: T, secret: string, salt: string, expiresIn?: number): Promise<string>;
+export declare function symmetricDecodeJWT<T = any>(token: string, secret: string, salt: string): Promise<T | null>;

package/dist/src/crypto/password.d.ts

@@ -0,0 +1,5 @@
+export declare const hashPassword: (password: string) => Promise<string>;
+export declare const verifyPassword: ({ hash, password, }: {
+    hash: string;
+    password: string;
+}) => Promise<boolean>;

package/dist/src/crypto/random.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomString: <SubA extends "a-z" | "A-Z" | "0-9" | "-_">(length: number, ...alphabets: SubA[]) => string;

package/dist/src/db/field.d.ts

@@ -0,0 +1,97 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBFieldAttribute, DBFieldAttributeConfig, DBFieldType } from "@gatwech/core/db";
+export declare const createFieldAttribute: <T extends DBFieldType, C extends DBFieldAttributeConfig>(type: T, config?: C | undefined) => {
+    required?: boolean | undefined;
+    returned?: boolean | undefined;
+    input?: boolean | undefined;
+    defaultValue?: (import("@gatwech/core/db").DBPrimitive | (() => import("@gatwech/core/db").DBPrimitive)) | undefined;
+    onUpdate?: (() => import("@gatwech/core/db").DBPrimitive) | undefined;
+    transform?: {
+        input?: (value: import("@gatwech/core/db").DBPrimitive) => import("@gatwech/core/db").DBPrimitive | Promise<import("@gatwech/core/db").DBPrimitive>;
+        output?: (value: import("@gatwech/core/db").DBPrimitive) => import("@gatwech/core/db").DBPrimitive | Promise<import("@gatwech/core/db").DBPrimitive>;
+    } | undefined;
+    references?: {
+        model: string;
+        field: string;
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+    } | undefined;
+    unique?: boolean | undefined;
+    bigint?: boolean | undefined;
+    validator?: {
+        input?: import("@standard-schema/spec").StandardSchemaV1;
+        output?: import("@standard-schema/spec").StandardSchemaV1;
+    } | undefined;
+    fieldName?: string | undefined;
+    sortable?: boolean | undefined;
+    type: T;
+};
+export type InferValueType<T extends DBFieldType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : T extends "json" ? Record<string, any> : T extends `${infer U}[]` ? U extends "string" ? string[] : number[] : T extends Array<any> ? T[number] : never;
+export type InferFieldsOutput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? {
+    [key in Key as Field[key]["required"] extends false ? Field[key]["defaultValue"] extends boolean | string | number | Date ? key : never : key]: InferFieldOutput<Field[key]>;
+} & {
+    [key in Key as Field[key]["returned"] extends false ? never : key]?: InferFieldOutput<Field[key]> | null;
+} : {};
+export type InferFieldsInput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? {
+    [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferFieldInput<Field[key]>;
+} & {
+    [key in Key as Field[key]["input"] extends false ? never : key]?: InferFieldInput<Field[key]> | undefined | null;
+} : {};
+/**
+ * For client will add "?" on optional fields
+ */
+export type InferFieldsInputClient<Field> = Field extends Record<infer Key, DBFieldAttribute> ? {
+    [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferFieldInput<Field[key]>;
+} & {
+    [key in Key as Field[key]["input"] extends false ? never : Field[key]["required"] extends false ? key : Field[key]["defaultValue"] extends string | number | boolean | Date ? key : never]?: InferFieldInput<Field[key]> | undefined | null;
+} : {};
+type InferFieldOutput<T extends DBFieldAttribute> = T["returned"] extends false ? never : T["required"] extends false ? InferValueType<T["type"]> | undefined | null : InferValueType<T["type"]>;
+/**
+ * Converts a Record<string, DBFieldAttribute> to an object type
+ * with keys and value types inferred from DBFieldAttribute["type"].
+ */
+export type FieldAttributeToObject<Fields extends Record<string, DBFieldAttribute>> = AddOptionalFields<{
+    [K in keyof Fields]: InferValueType<Fields[K]["type"]>;
+}, Fields>;
+type AddOptionalFields<T extends Record<string, any>, Fields extends Record<keyof T, DBFieldAttribute>> = {
+    [K in keyof T as Fields[K] extends {
+        required: true;
+    } ? K : never]: T[K];
+} & {
+    [K in keyof T as Fields[K] extends {
+        required: true;
+    } ? never : K]?: T[K];
+};
+/**
+ * Infer the additional fields from the plugin options.
+ * For example, you can infer the additional fields of the org plugin's organization schema like this:
+ * ```ts
+ * type AdditionalFields = InferAdditionalFieldsFromPluginOptions<"organization", OrganizationOptions>
+ * ```
+ */
+export type InferAdditionalFieldsFromPluginOptions<SchemaName extends string, Options extends {
+    schema?: {
+        [key in SchemaName]?: {
+            additionalFields?: Record<string, DBFieldAttribute>;
+        };
+    } | undefined;
+}, isClientSide extends boolean = true> = Options["schema"] extends {
+    [key in SchemaName]?: {
+        additionalFields: infer Field extends Record<string, DBFieldAttribute>;
+    };
+} ? isClientSide extends true ? FieldAttributeToObject<RemoveFieldsWithInputFalse<Field>> : FieldAttributeToObject<Field> : {};
+type RemoveFieldsWithInputFalse<T extends Record<string, DBFieldAttribute>> = {
+    [K in keyof T as T[K]["input"] extends false ? never : K]: T[K];
+};
+type InferFieldInput<T extends DBFieldAttribute> = InferValueType<T["type"]>;
+export type PluginFieldAttribute = Omit<DBFieldAttribute, "transform" | "defaultValue" | "hashValue">;
+export type InferFieldsFromPlugins<Options extends PayvoAuthOptions, Key extends string, Format extends "output" | "input" = "output"> = Options["plugins"] extends [] ? {} : Options["plugins"] extends Array<infer T> ? T extends {
+    schema: {
+        [key in Key]: {
+            fields: infer Field;
+        };
+    };
+} ? Format extends "output" ? InferFieldsOutput<Field> : InferFieldsInput<Field> : {} : {};
+export type InferFieldsFromOptions<Options extends PayvoAuthOptions, Key extends "session" | "user", Format extends "output" | "input" = "output"> = Options[Key] extends {
+    additionalFields: infer Field;
+} ? Format extends "output" ? InferFieldsOutput<Field> : InferFieldsInput<Field> : {};
+export {};

package/dist/src/db/get-migration.d.ts

@@ -0,0 +1,18 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBFieldAttribute, DBFieldType } from "@gatwech/core/db";
+import type { KyselyDatabaseType } from "../adapters/kysely-adapter/types";
+export declare function matchType(columnDataType: string, fieldType: DBFieldType, dbType: KyselyDatabaseType): boolean;
+export declare function getMigrations(config: PayvoAuthOptions): Promise<{
+    toBeCreated: {
+        table: string;
+        fields: Record<string, DBFieldAttribute>;
+        order: number;
+    }[];
+    toBeAdded: {
+        table: string;
+        fields: Record<string, DBFieldAttribute>;
+        order: number;
+    }[];
+    runMigrations: () => Promise<void>;
+    compileMigrations: () => Promise<string>;
+}>;

package/dist/src/db/get-schema.d.ts

@@ -0,0 +1,6 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBFieldAttribute } from "@gatwech/core/db";
+export declare function getSchema(config: PayvoAuthOptions): Record<string, {
+    fields: Record<string, DBFieldAttribute>;
+    order: number;
+}>;

package/dist/src/db/get-tables.d.ts

@@ -0,0 +1,3 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { PayvoAuthDBSchema } from "@gatwech/core/db";
+export declare const getAuthTables: (options: PayvoAuthOptions) => PayvoAuthDBSchema;

package/dist/src/db/index.d.ts

@@ -0,0 +1,10 @@
+export * from "@gatwech/core/db";
+export * from "./field";
+export * from "./get-migration";
+export * from "./get-schema";
+export * from "./get-tables";
+export * from "./internal-adapter";
+export * from "./schema";
+export * from "./to-zod";
+export * from "./utils";
+export * from "./with-hooks";

package/dist/src/db/internal-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { AuthContext, PayvoAuthOptions, InternalAdapter } from "@gatwech/core";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+import type { InternalLogger } from "@gatwech/core/env";
+export declare const createInternalAdapter: (adapter: DBAdapter<PayvoAuthOptions>, ctx: {
+    options: Omit<PayvoAuthOptions, "logger">;
+    logger: InternalLogger;
+    hooks: Exclude<PayvoAuthOptions["databaseHooks"], undefined>[];
+    generateId: AuthContext["generateId"];
+}) => InternalAdapter;

package/dist/src/db/schema.d.ts

@@ -0,0 +1,76 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { PayvoAuthPluginDBSchema, DBFieldAttribute } from "@gatwech/core/db";
+import type { Account, Session, User } from "../types";
+export declare function parseUserOutput(options: PayvoAuthOptions, user: User): {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    email: string;
+    emailVerified: boolean;
+    name: string;
+    image?: string | null | undefined;
+};
+export declare function parseAccountOutput(options: PayvoAuthOptions, account: Account): {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    providerId: string;
+    accountId: string;
+    userId: string;
+    accessToken?: string | null | undefined;
+    refreshToken?: string | null | undefined;
+    idToken?: string | null | undefined;
+    accessTokenExpiresAt?: Date | null | undefined;
+    refreshTokenExpiresAt?: Date | null | undefined;
+    scope?: string | null | undefined;
+    password?: string | null | undefined;
+};
+export declare function parseSessionOutput(options: PayvoAuthOptions, session: Session): {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+};
+export declare function parseInputData<T extends Record<string, any>>(data: T, schema: {
+    fields: Record<string, DBFieldAttribute>;
+    action?: ("create" | "update") | undefined;
+}): Partial<T>;
+export declare function parseUserInput(options: PayvoAuthOptions, user: Record<string, any> | undefined, action: "create" | "update"): Partial<Record<string, any>>;
+export declare function parseAdditionalUserInput(options: PayvoAuthOptions, user?: Record<string, any> | undefined): Partial<Record<string, any>>;
+export declare function parseAccountInput(options: PayvoAuthOptions, account: Partial<Account>): Partial<Partial<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    providerId: string;
+    accountId: string;
+    userId: string;
+    accessToken?: string | null | undefined;
+    refreshToken?: string | null | undefined;
+    idToken?: string | null | undefined;
+    accessTokenExpiresAt?: Date | null | undefined;
+    refreshTokenExpiresAt?: Date | null | undefined;
+    scope?: string | null | undefined;
+    password?: string | null | undefined;
+}>>;
+export declare function parseSessionInput(options: PayvoAuthOptions, session: Partial<Session>): Partial<Partial<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+}>>;
+export declare function mergeSchema<S extends PayvoAuthPluginDBSchema>(schema: S, newSchema?: {
+    [K in keyof S]?: {
+        modelName?: string;
+        fields?: {
+            [P: string]: string;
+        };
+    };
+} | undefined): S;

package/dist/src/db/to-zod.d.ts

@@ -0,0 +1,31 @@
+import type { DBFieldAttribute } from "@gatwech/core/db";
+import * as z from "zod";
+export declare function toZodSchema<Fields extends Record<string, DBFieldAttribute | never>, IsClientSide extends boolean>({ fields, isClientSide, }: {
+    fields: Fields;
+    /**
+     * If true, then any fields that have `input: false` will be removed from the schema to prevent user input.
+     */
+    isClientSide: IsClientSide;
+}): z.ZodObject<RemoveNeverProps<{ [key in keyof Fields]: FieldAttributeToSchema<Fields[key], IsClientSide>; }>, z.core.$strip>;
+export type FieldAttributeToSchema<Field extends DBFieldAttribute | Record<string, never>, isClientSide extends boolean = false> = Field extends {
+    type: any;
+} ? GetInput<isClientSide, Field, GetRequired<Field, GetType<Field>>> : Record<string, never>;
+type GetType<F extends DBFieldAttribute> = F extends {
+    type: "string";
+} ? z.ZodString : F extends {
+    type: "number";
+} ? z.ZodNumber : F extends {
+    type: "boolean";
+} ? z.ZodBoolean : F extends {
+    type: "date";
+} ? z.ZodDate : z.ZodAny;
+type GetRequired<F extends DBFieldAttribute, Schema extends z.core.SomeType> = F extends {
+    required: true;
+} ? Schema : z.ZodOptional<Schema>;
+type GetInput<isClientSide extends boolean, Field extends DBFieldAttribute, Schema extends z.core.SomeType> = Field extends {
+    input: false;
+} ? isClientSide extends true ? never : Schema : Schema;
+type RemoveNeverProps<T> = {
+    [K in keyof T as [T[K]] extends [never] ? never : K]: T[K];
+};
+export {};

package/dist/src/db/utils.d.ts

@@ -0,0 +1,6 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBFieldAttribute } from "@gatwech/core/db";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+export declare function getAdapter(options: PayvoAuthOptions): Promise<DBAdapter<PayvoAuthOptions>>;
+export declare function convertToDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T): T;
+export declare function convertFromDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T | null): T | null;

package/dist/src/db/with-hooks.d.ts

@@ -0,0 +1,27 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter, Where } from "@gatwech/core/db/adapter";
+export declare function getWithHooks(adapter: DBAdapter<PayvoAuthOptions>, ctx: {
+    options: PayvoAuthOptions;
+    hooks: Exclude<PayvoAuthOptions["databaseHooks"], undefined>[];
+}): {
+    createWithHooks: <T extends Record<string, any>>(data: T, model: "session" | "user" | "account" | "verification", customCreateFn?: {
+        fn: (data: Record<string, any>) => void | Promise<any>;
+        executeMainFn?: boolean;
+    } | undefined) => Promise<any>;
+    updateWithHooks: <T extends Record<string, any>>(data: any, where: Where[], model: "session" | "user" | "account" | "verification", customUpdateFn?: {
+        fn: (data: Record<string, any>) => void | Promise<any>;
+        executeMainFn?: boolean;
+    } | undefined) => Promise<any>;
+    updateManyWithHooks: <T extends Record<string, any>>(data: any, where: Where[], model: "session" | "user" | "account" | "verification", customUpdateFn?: {
+        fn: (data: Record<string, any>) => void | Promise<any>;
+        executeMainFn?: boolean;
+    } | undefined) => Promise<any>;
+    deleteWithHooks: <T extends Record<string, any>>(where: Where[], model: "session" | "user" | "account" | "verification", customDeleteFn?: {
+        fn: (where: Where[]) => void | Promise<any>;
+        executeMainFn?: boolean;
+    } | undefined) => Promise<any>;
+    deleteManyWithHooks: <T extends Record<string, any>>(where: Where[], model: "session" | "user" | "account" | "verification", customDeleteFn?: {
+        fn: (where: Where[]) => void | Promise<any>;
+        executeMainFn?: boolean;
+    } | undefined) => Promise<any>;
+};