@gatwech/core 0.0.11 → 1.0.0-beta.19

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

@@ -0,0 +1,119 @@
+import { type EndpointContext, type EndpointOptions } from "better-call";
+import type { AuthContext } from "../types";
+export declare const optionsMiddleware: <InputCtx extends import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>>(inputContext: InputCtx) => Promise<AuthContext>;
+export declare const createAuthMiddleware: {
+    <Options extends import("better-call").MiddlewareOptions, R>(options: Options, handler: (ctx: import("better-call").MiddlewareContext<Options, AuthContext & {
+        returned?: unknown | undefined;
+        responseHeaders?: Headers | undefined;
+    }>) => Promise<R>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R>;
+    <Options extends import("better-call").MiddlewareOptions, R_1>(handler: (ctx: import("better-call").MiddlewareContext<Options, AuthContext & {
+        returned?: unknown | undefined;
+        responseHeaders?: Headers | undefined;
+    }>) => Promise<R_1>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R_1>;
+};
+export declare const createAuthEndpoint: <Path extends string, Opts extends EndpointOptions, R>(path: Path, options: Opts, handler: (ctx: EndpointContext<Path, Opts, AuthContext>) => Promise<R>) => {
+    <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: import("better-call").HasRequiredKeys<import("better-call").InputContext<Path, Opts & {
+        use: any[];
+    }>> extends true ? [import("better-call").InferBodyInput<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["metadata"] extends {
+        $Infer: {
+            body: infer B;
+        };
+    } ? B : (Opts & {
+        use: any[];
+    })["body"] extends import("better-call").StandardSchemaV1<unknown, unknown> ? import("better-call").StandardSchemaV1.InferInput<(Opts & {
+        use: any[];
+    })["body"]> : undefined> & import("better-call").InferInputMethod<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["method"] extends any[] ? (Opts & {
+        use: any[];
+    })["method"][number] : (Opts & {
+        use: any[];
+    })["method"] extends "*" ? import("better-call").HTTPMethod : (Opts & {
+        use: any[];
+    })["method"] | undefined> & import("better-call").InferQueryInput<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["metadata"] extends {
+        $Infer: {
+            query: infer Query;
+        };
+    } ? Query : (Opts & {
+        use: any[];
+    })["query"] extends import("better-call").StandardSchemaV1<unknown, unknown> ? import("better-call").StandardSchemaV1.InferInput<(Opts & {
+        use: any[];
+    })["query"]> : Record<string, any> | undefined> & import("better-call").InferParamInput<Path> & import("better-call").InferRequestInput<Opts & {
+        use: any[];
+    }> & import("better-call").InferHeadersInput<Opts & {
+        use: any[];
+    }> & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: import("better-call").Middleware[];
+        path?: string;
+    } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+    }] : [((import("better-call").InferBodyInput<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["metadata"] extends {
+        $Infer: {
+            body: infer B;
+        };
+    } ? B : (Opts & {
+        use: any[];
+    })["body"] extends import("better-call").StandardSchemaV1<unknown, unknown> ? import("better-call").StandardSchemaV1.InferInput<(Opts & {
+        use: any[];
+    })["body"]> : undefined> & import("better-call").InferInputMethod<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["method"] extends any[] ? (Opts & {
+        use: any[];
+    })["method"][number] : (Opts & {
+        use: any[];
+    })["method"] extends "*" ? import("better-call").HTTPMethod : (Opts & {
+        use: any[];
+    })["method"] | undefined> & import("better-call").InferQueryInput<Opts & {
+        use: any[];
+    }, (Opts & {
+        use: any[];
+    })["metadata"] extends {
+        $Infer: {
+            query: infer Query;
+        };
+    } ? Query : (Opts & {
+        use: any[];
+    })["query"] extends import("better-call").StandardSchemaV1<unknown, unknown> ? import("better-call").StandardSchemaV1.InferInput<(Opts & {
+        use: any[];
+    })["query"]> : Record<string, any> | undefined> & import("better-call").InferParamInput<Path> & import("better-call").InferRequestInput<Opts & {
+        use: any[];
+    }> & import("better-call").InferHeadersInput<Opts & {
+        use: any[];
+    }> & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: import("better-call").Middleware[];
+        path?: string;
+    } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+    }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: R;
+    } : R>;
+    options: Opts & {
+        use: any[];
+    };
+    path: Path;
+};
+export type AuthEndpoint = ReturnType<typeof createAuthEndpoint>;
+export type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;

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

@@ -0,0 +1,6 @@
+/**
+ * AsyncLocalStorage will be import directly in 1.5.x
+ */
+import type { AsyncLocalStorage } from "node:async_hooks";
+export type { AsyncLocalStorage };
+export declare function getAsyncLocalStorage(): Promise<typeof AsyncLocalStorage>;

package/dist/src/context/endpoint-context.d.ts

@@ -0,0 +1,14 @@
+import type { EndpointContext, InputContext } from "better-call";
+import { type AsyncLocalStorage } from "../async_hooks";
+import type { AuthContext } from "../types";
+export type AuthEndpointContext = Partial<InputContext<string, any> & EndpointContext<string, any>> & {
+    context: AuthContext;
+};
+/**
+ * This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+export declare function getCurrentAuthContextAsyncLocalStorage(): Promise<AsyncLocalStorage<AuthEndpointContext>>;
+export declare function getCurrentAuthContext(): Promise<AuthEndpointContext>;
+export declare function runWithEndpointContext<T>(context: AuthEndpointContext, fn: () => T): Promise<T>;

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

@@ -0,0 +1,3 @@
+export { type AuthEndpointContext, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext, } from "./endpoint-context";
+export { defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, type RequestState, type RequestStateWeakMap, runWithRequestState, } from "./request-state";
+export { getCurrentAdapter, getCurrentDBAdapterAsyncLocalStorage, runWithAdapter, runWithTransaction, } from "./transaction";

package/dist/src/context/request-state.d.ts

@@ -0,0 +1,13 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { type AsyncLocalStorage } from "../async_hooks";
+export type RequestStateWeakMap = WeakMap<StandardSchemaV1, any>;
+export declare function getRequestStateAsyncLocalStorage(): Promise<AsyncLocalStorage<RequestStateWeakMap>>;
+export declare function hasRequestState(): Promise<boolean>;
+export declare function getCurrentRequestState(): Promise<RequestStateWeakMap>;
+export declare function runWithRequestState<T>(store: RequestStateWeakMap, fn: () => T): Promise<T>;
+export interface RequestState<T> {
+    get<S>(): Promise<S & T>;
+    set(value: T): Promise<void>;
+}
+export declare function defineRequestState<T>(schema?: StandardSchemaV1<T>): RequestState<T>;
+export declare function defineRequestState<Schema extends StandardSchemaV1>(schema?: Schema): RequestState<StandardSchemaV1.InferInput<Schema>>;

package/dist/src/context/transaction.d.ts

@@ -0,0 +1,11 @@
+import { type AsyncLocalStorage } from "../async_hooks";
+import type { DBAdapter, DBTransactionAdapter } from "../db/adapter";
+/**
+ * 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 declare const getCurrentDBAdapterAsyncLocalStorage: () => Promise<AsyncLocalStorage<DBTransactionAdapter>>;
+export declare const getCurrentAdapter: (fallback: DBTransactionAdapter) => Promise<DBTransactionAdapter>;
+export declare const runWithAdapter: <R>(adapter: DBAdapter, fn: () => R) => Promise<R>;
+export declare const runWithTransaction: <R>(adapter: DBAdapter, fn: () => R) => Promise<R>;

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

@@ -0,0 +1,401 @@
+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 Payvo-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 Payvo-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 Payvo-Auth instance.
+         */
+        schema: PayvoAuthDBSchema;
+        /**
+         * The options of the user's Payvo-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 Payvo-Auth instance.
+         */
+        schema: PayvoAuthDBSchema;
+        /**
+         * The options of the user's Payvo-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 Payvo-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 Payvo-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 → dist/src/db/index.d.ts}

@@ -1,12 +1,5 @@
 import type { PayvoAuthPluginDBSchema } from "./plugin";
-import type {
-  PayvoAuthDBSchema,
-  DBFieldAttribute,
-  DBFieldAttributeConfig,
-  DBFieldType,
-  DBPrimitive,
-} from "./type";
-
+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";
@@ -14,16 +7,7 @@ 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";
-
+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
  */

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

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

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

@@ -0,0 +1,22 @@
+import * as z from "zod";
+export declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+    providerId: z.ZodString;
+    accountId: z.ZodString;
+    userId: z.ZodCoercedString<unknown>;
+    accessToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    refreshToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    idToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    accessTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    refreshTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * 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>;

package/dist/src/db/schema/rate-limit.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod";
+export declare const rateLimitSchema: z.ZodObject<{
+    key: z.ZodString;
+    count: z.ZodNumber;
+    lastRequest: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Rate limit schema type used by payvo-auth for rate limiting
+ */
+export type RateLimit = z.infer<typeof rateLimitSchema>;

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

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export declare const sessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+    userId: z.ZodCoercedString<unknown>;
+    expiresAt: z.ZodDate;
+    token: z.ZodString;
+    ipAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Session schema type used by payvo-auth, note that it's possible that session 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 Session = z.infer<typeof sessionSchema>;

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

@@ -0,0 +1,6 @@
+import * as z from "zod";
+export declare const coreSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, z.core.$strip>;