@gatwech/auth 1.0.0-beta.18

package/dist/src/adapters/drizzle-adapter/drizzle-adapter.d.ts

@@ -0,0 +1,43 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+export interface DB {
+    [key: string]: any;
+}
+export interface DrizzleAdapterConfig {
+    /**
+     * The schema object that defines the tables and fields
+     */
+    schema?: Record<string, any> | undefined;
+    /**
+     * The database provider
+     */
+    provider: "pg" | "mysql" | "sqlite";
+    /**
+     * If the table names in the schema are plural
+     * set this to true. For example, if the schema
+     * has an object with a key "users" instead of "user"
+     */
+    usePlural?: boolean | undefined;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: DBAdapterDebugLogOption | undefined;
+    /**
+     * By default snake case is used for table and field names
+     * when the CLI is used to generate the schema. If you want
+     * to use camel case, set this to true.
+     * @default false
+     */
+    camelCase?: boolean | undefined;
+    /**
+     * Whether to 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?: boolean | undefined;
+}
+export declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;

package/dist/src/adapters/drizzle-adapter/index.d.ts

@@ -0,0 +1 @@
+export * from "./drizzle-adapter";

package/dist/src/adapters/drizzle-adapter/test/generate-schema.d.ts

@@ -0,0 +1,12 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+/**
+ * generates a drizzle schema based on PayvoAuthOptions & a given dialect.
+ *
+ * Useful for testing the Drizzle adapter.
+ */
+export declare const generateDrizzleSchema: (db: any, options: PayvoAuthOptions, dialect: "sqlite" | "mysql" | "pg") => Promise<{
+    schema: any;
+    fileName: string;
+}>;
+export declare const clearSchemaCache: () => void;
+export declare const resetGenerationCount: () => void;

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

@@ -0,0 +1,21 @@
+import { type AdapterFactory, type AdapterFactoryCustomizeAdapterCreator, type AdapterFactoryOptions, type AdapterTestDebugLogs, createAdapterFactory } from "./adapter-factory";
+export * from "@gatwech/core/db/adapter";
+import type { CustomAdapter, DBAdapterFactoryConfig } from "@gatwech/core/db/adapter";
+export type { AdapterFactoryOptions, AdapterFactory, AdapterTestDebugLogs, DBAdapterFactoryConfig, CustomAdapter, AdapterFactoryCustomizeAdapterCreator, };
+export { createAdapterFactory };
+/**
+ * @deprecated Use `createAdapterFactory` instead. This export will be removed in the next major version.
+ */
+export declare const createAdapter: ({ adapter: customAdapter, config: cfg, }: AdapterFactoryOptions) => AdapterFactory;
+/**
+ * @deprecated Use `AdapterFactoryOptions` instead. This export will be removed in the next major version.
+ */
+export type CreateAdapterOptions = AdapterFactoryOptions;
+/**
+ * @deprecated Use `AdapterFactoryConfig` instead. This export will be removed in the next major version.
+ */
+export type AdapterConfig = DBAdapterFactoryConfig;
+/**
+ * @deprecated Use `AdapterFactoryCustomizeAdapterCreator` instead. This export will be removed in the next major version.
+ */
+export type CreateCustomAdapter = AdapterFactoryCustomizeAdapterCreator;

package/dist/src/adapters/kysely-adapter/bun-sqlite-dialect.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @see {@link https://github.com/dylanblokhuis/kysely-bun-sqlite} - Fork of the original kysely-bun-sqlite package by @dylanblokhuis
+ */
+import type { Database } from "bun:sqlite";
+import { type DatabaseConnection, type DatabaseIntrospector, type DatabaseMetadata, type DatabaseMetadataOptions, DefaultQueryCompiler, type Dialect, type DialectAdapter, DialectAdapterBase, type Driver, Kysely, type QueryCompiler, type SchemaMetadata, type TableMetadata } from "kysely";
+export declare class BunSqliteAdapter implements DialectAdapterBase {
+    get supportsCreateIfNotExists(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    acquireMigrationLock(): Promise<void>;
+    releaseMigrationLock(): Promise<void>;
+    get supportsOutput(): boolean;
+}
+/**
+ * Config for the SQLite dialect.
+ */
+export interface BunSqliteDialectConfig {
+    /**
+     * An sqlite Database instance or a function that returns one.
+     */
+    database: Database;
+    /**
+     * Called once when the first query is executed.
+     */
+    onCreateConnection?: ((connection: DatabaseConnection) => Promise<void>) | undefined;
+}
+export declare class BunSqliteDriver implements Driver {
+    #private;
+    constructor(config: BunSqliteDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(connection: DatabaseConnection): Promise<void>;
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare class BunSqliteIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<unknown>);
+    getSchemas(): Promise<SchemaMetadata[]>;
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    getMetadata(options?: DatabaseMetadataOptions | undefined): Promise<DatabaseMetadata>;
+}
+export declare class BunSqliteQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
+    protected getAutoIncrement(): string;
+}
+export declare class BunSqliteDialect implements Dialect {
+    #private;
+    constructor(config: BunSqliteDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}

package/dist/src/adapters/kysely-adapter/dialect.d.ts

@@ -0,0 +1,13 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import { Kysely } from "kysely";
+import type { KyselyDatabaseType } from "./types";
+export declare function getKyselyDatabaseType(db: PayvoAuthOptions["database"]): KyselyDatabaseType | null;
+export declare const createKyselyAdapter: (config: PayvoAuthOptions) => Promise<{
+    kysely: Kysely<any>;
+    databaseType: "postgres" | "mysql" | "sqlite" | "mssql";
+    transaction: boolean | undefined;
+} | {
+    kysely: Kysely<any> | null;
+    databaseType: KyselyDatabaseType | null;
+    transaction: undefined;
+}>;

package/dist/src/adapters/kysely-adapter/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dialect";
+export * from "./kysely-adapter";
+export * from "./types";

package/dist/src/adapters/kysely-adapter/kysely-adapter.d.ts

@@ -0,0 +1,32 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+import { type Kysely } from "kysely";
+import type { KyselyDatabaseType } from "./types";
+interface KyselyAdapterConfig {
+    /**
+     * Database type.
+     */
+    type?: KyselyDatabaseType | undefined;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: DBAdapterDebugLogOption | undefined;
+    /**
+     * Use plural for table names.
+     *
+     * @default false
+     */
+    usePlural?: boolean | undefined;
+    /**
+     * Whether to 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?: boolean | undefined;
+}
+export declare const kyselyAdapter: (db: Kysely<any>, config?: KyselyAdapterConfig | undefined) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+export {};

package/dist/src/adapters/kysely-adapter/node-sqlite-dialect.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @see {@link https://nodejs.org/api/sqlite.html} - Node.js SQLite API documentation
+ */
+import type { DatabaseSync } from "node:sqlite";
+import { type DatabaseConnection, type DatabaseIntrospector, type DatabaseMetadata, type DatabaseMetadataOptions, DefaultQueryCompiler, type Dialect, type DialectAdapter, DialectAdapterBase, type Driver, Kysely, type QueryCompiler, type SchemaMetadata, type TableMetadata } from "kysely";
+export declare class NodeSqliteAdapter implements DialectAdapterBase {
+    get supportsCreateIfNotExists(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    acquireMigrationLock(): Promise<void>;
+    releaseMigrationLock(): Promise<void>;
+    get supportsOutput(): boolean;
+}
+/**
+ * Config for the SQLite dialect.
+ */
+export interface NodeSqliteDialectConfig {
+    /**
+     * A sqlite DatabaseSync instance or a function that returns one.
+     */
+    database: DatabaseSync;
+    /**
+     * Called once when the first query is executed.
+     */
+    onCreateConnection?: ((connection: DatabaseConnection) => Promise<void>) | undefined;
+}
+export declare class NodeSqliteDriver implements Driver {
+    #private;
+    constructor(config: NodeSqliteDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(connection: DatabaseConnection): Promise<void>;
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare class NodeSqliteIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<unknown>);
+    getSchemas(): Promise<SchemaMetadata[]>;
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    getMetadata(options?: DatabaseMetadataOptions | undefined): Promise<DatabaseMetadata>;
+}
+export declare class NodeSqliteQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
+    protected getAutoIncrement(): string;
+}
+export declare class NodeSqliteDialect implements Dialect {
+    #private;
+    constructor(config: NodeSqliteDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}

package/dist/src/adapters/kysely-adapter/types.d.ts

@@ -0,0 +1 @@
+export type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";

package/dist/src/adapters/memory-adapter/index.d.ts

@@ -0,0 +1 @@
+export * from "./memory-adapter";

package/dist/src/adapters/memory-adapter/memory-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+export interface MemoryDB {
+    [key: string]: any[];
+}
+export interface MemoryAdapterConfig {
+    debugLogs?: DBAdapterDebugLogOption | undefined;
+}
+export declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig | undefined) => (options: PayvoAuthOptions) => import("packages/core/dist/index-65G5U5DB.mjs").nt<PayvoAuthOptions>;

package/dist/src/adapters/mongodb-adapter/index.d.ts

@@ -0,0 +1 @@
+export * from "./mongodb-adapter";

package/dist/src/adapters/mongodb-adapter/mongodb-adapter.d.ts

@@ -0,0 +1,31 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+import { type Db, type MongoClient } from "mongodb";
+export interface MongoDBAdapterConfig {
+    /**
+     * MongoDB client instance
+     * If not provided, Database transactions won't be enabled.
+     */
+    client?: MongoClient | undefined;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: DBAdapterDebugLogOption | undefined;
+    /**
+     * Use plural table names
+     *
+     * @default false
+     */
+    usePlural?: boolean | undefined;
+    /**
+     * Whether to 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?: boolean | undefined;
+}
+export declare const mongodbAdapter: (db: Db, config?: MongoDBAdapterConfig | undefined) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;

package/dist/src/adapters/prisma-adapter/index.d.ts

@@ -0,0 +1 @@
+export * from "./prisma-adapter";

package/dist/src/adapters/prisma-adapter/prisma-adapter.d.ts

@@ -0,0 +1,32 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+export interface PrismaConfig {
+    /**
+     * Database provider.
+     */
+    provider: "sqlite" | "cockroachdb" | "mysql" | "postgresql" | "sqlserver" | "mongodb";
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: DBAdapterDebugLogOption | undefined;
+    /**
+     * Use plural table names
+     *
+     * @default false
+     */
+    usePlural?: boolean | undefined;
+    /**
+     * Whether to 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?: boolean | undefined;
+}
+interface PrismaClient {
+}
+export declare const prismaAdapter: (prisma: PrismaClient, config: PrismaConfig) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+export {};

package/dist/src/adapters/prisma-adapter/test/auth.d.ts

@@ -0,0 +1,3 @@
+export declare const auth: import("../../..").Auth<{
+    database: (options: import("packages/core/dist/index-65G5U5DB.mjs").g) => import("packages/core/dist/index-65G5U5DB.mjs").nt<import("packages/core/dist/index-65G5U5DB.mjs").g>;
+}>;

package/dist/src/adapters/prisma-adapter/test/generate-auth-config.d.ts

@@ -0,0 +1,2 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+export declare const generateAuthConfigFile: (_options: PayvoAuthOptions) => Promise<void>;

package/dist/src/adapters/prisma-adapter/test/generate-prisma-schema.d.ts

@@ -0,0 +1,3 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { PrismaClient } from "@prisma/client";
+export declare function generatePrismaSchema(PayvoAuthOptions: PayvoAuthOptions, db: PrismaClient, iteration: number, dialect: "sqlite" | "postgresql" | "mysql"): Promise<void>;

package/dist/src/adapters/prisma-adapter/test/get-prisma-client.d.ts

@@ -0,0 +1,7 @@
+import type { PrismaClient } from "@prisma/client";
+export declare const getPrismaClient: (dialect: "sqlite" | "postgresql" | "mysql") => Promise<PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, unknown, import("@prisma/client/runtime/library").InternalArgs>>;
+export declare const incrementMigrationCount: () => number;
+export declare const destroyPrismaClient: ({ migrationCount, dialect, }: {
+    migrationCount: number;
+    dialect: "sqlite" | "postgresql" | "mysql";
+}) => void;

package/dist/src/adapters/prisma-adapter/test/push-prisma-schema.d.ts

@@ -0,0 +1 @@
+export declare function pushPrismaSchema(dialect: "sqlite" | "postgresql" | "mysql"): Promise<void>;

package/dist/src/adapters/test-adapter.d.ts

@@ -0,0 +1,61 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+import type { createTestSuite } from "./create-test-suite";
+export type Logger = {
+    info: (...args: any[]) => void;
+    success: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+};
+export declare const testAdapter: ({ adapter: getAdapter, runMigrations, overridePayvoAuthOptions, additionalCleanups, tests, prefixTests, onFinish, customIdGenerator, transformIdOutput, }: {
+    /**
+     * A function that will return the adapter instance to test with.
+     *
+     * @example
+     * ```ts
+     * testAdapter({
+     *   adapter: (options) => drizzleAdapter(drizzle(db), {
+     *     schema: generateSchema(options),
+     *   }),
+     * })
+     */
+    adapter: (options: PayvoAuthOptions) => Promise<(options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>> | ((options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>);
+    /**
+     * A function that will run the database migrations.
+     */
+    runMigrations: (PayvoAuthOptions: PayvoAuthOptions) => Promise<void> | void;
+    /**
+     * Any potential payvo-auth options overrides.
+     */
+    overridePayvoAuthOptions?: <Passed extends PayvoAuthOptions, Returned extends PayvoAuthOptions>(PayvoAuthOptions: Passed) => Returned;
+    /**
+     * By default we will cleanup all tables automatically,
+     * but if you have additional cleanup logic, you can pass it here.
+     *
+     * Such as deleting a DB file that could had been created.
+     */
+    additionalCleanups?: () => Promise<void> | void;
+    /**
+     * A test suite to run.
+     */
+    tests: ReturnType<ReturnType<typeof createTestSuite>>[];
+    /**
+     * A prefix to add to the test suite name.
+     */
+    prefixTests?: string;
+    /**
+     * Upon finish of the tests, this function will be called.
+     */
+    onFinish?: () => Promise<void> | void;
+    /**
+     * Custom ID generator function to be used by the helper functions. (such as `insertRandom`)
+     */
+    customIdGenerator?: () => any;
+    /**
+     * A function that will transform the ID output.
+     */
+    transformIdOutput?: (id: any) => any;
+}) => Promise<{
+    execute: () => void;
+}>;

package/dist/src/adapters/test.d.ts

@@ -0,0 +1,78 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+import type { DBAdapter } from "@gatwech/core/db/adapter";
+interface AdapterTestOptions {
+    getAdapter: (customOptions?: Omit<PayvoAuthOptions, "database">) => Promise<DBAdapter<PayvoAuthOptions>> | DBAdapter<PayvoAuthOptions>;
+    disableTests?: Partial<Record<keyof typeof adapterTests, boolean>>;
+    testPrefix?: string;
+}
+interface NumberIdAdapterTestOptions {
+    getAdapter: (customOptions?: Omit<PayvoAuthOptions, "database">) => Promise<DBAdapter<PayvoAuthOptions>>;
+    disableTests?: Partial<Record<keyof typeof numberIdAdapterTests, boolean>>;
+    testPrefix?: string;
+}
+declare const adapterTests: {
+    readonly CREATE_MODEL: "create model";
+    readonly CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID: "create model should always return an id";
+    readonly FIND_MODEL: "find model";
+    readonly FIND_MODEL_WITHOUT_ID: "find model without id";
+    readonly FIND_MODEL_WITH_SELECT: "find model with select";
+    readonly FIND_MODEL_WITH_MODIFIED_FIELD_NAME: "find model with modified field name";
+    readonly UPDATE_MODEL: "update model";
+    readonly SHOULD_FIND_MANY: "should find many";
+    readonly SHOULD_FIND_MANY_WITH_WHERE: "should find many with where";
+    readonly SHOULD_FIND_MANY_WITH_OPERATORS: "should find many with operators";
+    readonly SHOULD_WORK_WITH_REFERENCE_FIELDS: "should work with reference fields";
+    readonly SHOULD_FIND_MANY_WITH_NOT_IN_OPERATOR: "should find many with not in operator";
+    readonly SHOULD_FIND_MANY_WITH_SORT_BY: "should find many with sortBy";
+    readonly SHOULD_FIND_MANY_WITH_LIMIT: "should find many with limit";
+    readonly SHOULD_FIND_MANY_WITH_OFFSET: "should find many with offset";
+    readonly SHOULD_UPDATE_WITH_MULTIPLE_WHERE: "should update with multiple where";
+    readonly DELETE_MODEL: "delete model";
+    readonly SHOULD_DELETE_MANY: "should delete many";
+    readonly SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND: "shouldn't throw on delete record not found";
+    readonly SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND: "shouldn't throw on record not found";
+    readonly SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR: "should find many with contains operator";
+    readonly SHOULD_SEARCH_USERS_WITH_STARTS_WITH: "should search users with startsWith";
+    readonly SHOULD_SEARCH_USERS_WITH_ENDS_WITH: "should search users with endsWith";
+    readonly SHOULD_PREFER_GENERATE_ID_IF_PROVIDED: "should prefer generateId if provided";
+    readonly SHOULD_ROLLBACK_FAILING_TRANSACTION: "should rollback failing transaction";
+    readonly SHOULD_RETURN_TRANSACTION_RESULT: "should return transaction result";
+    readonly SHOULD_FIND_MANY_WITH_CONNECTORS: "should find many with connectors";
+};
+declare const numberIdAdapterTests: {
+    SHOULD_RETURN_A_NUMBER_ID_AS_A_RESULT: string;
+    SHOULD_INCREMENT_THE_ID_BY_1: string;
+    CREATE_MODEL: "create model";
+    CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID: "create model should always return an id";
+    FIND_MODEL: "find model";
+    FIND_MODEL_WITHOUT_ID: "find model without id";
+    FIND_MODEL_WITH_SELECT: "find model with select";
+    FIND_MODEL_WITH_MODIFIED_FIELD_NAME: "find model with modified field name";
+    UPDATE_MODEL: "update model";
+    SHOULD_FIND_MANY: "should find many";
+    SHOULD_FIND_MANY_WITH_WHERE: "should find many with where";
+    SHOULD_FIND_MANY_WITH_OPERATORS: "should find many with operators";
+    SHOULD_WORK_WITH_REFERENCE_FIELDS: "should work with reference fields";
+    SHOULD_FIND_MANY_WITH_NOT_IN_OPERATOR: "should find many with not in operator";
+    SHOULD_FIND_MANY_WITH_SORT_BY: "should find many with sortBy";
+    SHOULD_FIND_MANY_WITH_LIMIT: "should find many with limit";
+    SHOULD_FIND_MANY_WITH_OFFSET: "should find many with offset";
+    SHOULD_UPDATE_WITH_MULTIPLE_WHERE: "should update with multiple where";
+    DELETE_MODEL: "delete model";
+    SHOULD_DELETE_MANY: "should delete many";
+    SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND: "shouldn't throw on delete record not found";
+    SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND: "shouldn't throw on record not found";
+    SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR: "should find many with contains operator";
+    SHOULD_SEARCH_USERS_WITH_STARTS_WITH: "should search users with startsWith";
+    SHOULD_SEARCH_USERS_WITH_ENDS_WITH: "should search users with endsWith";
+    SHOULD_PREFER_GENERATE_ID_IF_PROVIDED: "should prefer generateId if provided";
+    SHOULD_ROLLBACK_FAILING_TRANSACTION: "should rollback failing transaction";
+    SHOULD_RETURN_TRANSACTION_RESULT: "should return transaction result";
+    SHOULD_FIND_MANY_WITH_CONNECTORS: "should find many with connectors";
+};
+export declare function runAdapterTest(opts: AdapterTestOptions): void;
+export declare function runNumberIdAdapterTest(opts: NumberIdAdapterTestOptions): void;
+export declare function recoverProcessTZ(): {
+    [Symbol.dispose]: () => void;
+};
+export {};

package/dist/src/adapters/tests/auth-flow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This test suite tests basic authentication flow using the adapter.
+ */
+export declare const authFlowTestSuite: (options?: ({
+    disableTests?: Partial<Record<"should successfully sign up" | "should successfully sign in" | "should successfully get session" | "should not sign in with invalid email" | "should store and retrieve timestamps correctly across timezones" | "should sign up with additional fields", boolean> & {
+        ALL?: boolean;
+    }> | undefined;
+} & {
+    showDB?: () => Promise<void>;
+}) | undefined) => (helpers: {
+    adapter: () => Promise<import("packages/core/dist/index-65G5U5DB.mjs").nt<import("packages/core/dist/index-65G5U5DB.mjs").g>>;
+    log: import("../test-adapter").Logger;
+    adapterDisplayName: string;
+    getPayvoAuthOptions: () => import("packages/core/dist/index-65G5U5DB.mjs").g;
+    modifyPayvoAuthOptions: (options: import("packages/core/dist/index-65G5U5DB.mjs").g) => Promise<import("packages/core/dist/index-65G5U5DB.mjs").g>;
+    cleanup: () => Promise<void>;
+    runMigrations: () => Promise<void>;
+    prefixTests?: string | undefined;
+    onTestFinish: () => Promise<void>;
+    customIdGenerator?: (() => any | Promise<any> | undefined) | undefined;
+    transformIdOutput?: ((id: any) => string | undefined) | undefined;
+}) => Promise<void>;

package/dist/src/adapters/tests/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./auth-flow";
+export * from "./normal";
+export * from "./number-id";
+export * from "./performance";
+export * from "./transactions";

package/dist/src/adapters/tests/normal.d.ts

@@ -0,0 +1,87 @@
+import { createTestSuite } from "../create-test-suite";
+/**
+ * This test suite tests the basic CRUD operations of the adapter.
+ */
+export declare const normalTestSuite: (options?: {
+    disableTests?: Partial<Record<"init - tests" | "create - should create a model" | "create - should always return an id" | "create - should use generateId if provided" | "create - should return null for nullable foreign keys" | "create - should apply default values to fields" | "findOne - should find a model" | "findOne - should not apply defaultValue if value not found" | "findOne - should find a model using a reference field" | "findOne - should not throw on record not found" | "findOne - should find a model without id" | "findOne - should find a model with modified field name" | "findOne - should find a model with modified model name" | "findOne - should find a model with additional fields" | "findOne - should select fields" | "findOne - should find model with date field" | "findMany - should find many models with date fields" | "findMany - should find many models" | "findMany - should return an empty array when no models are found" | "findMany - should find many models with starts_with operator" | "findMany - starts_with should not interpret regex patterns" | "findMany - ends_with should not interpret regex patterns" | "findMany - contains should not interpret regex patterns" | "findMany - should find many models with ends_with operator" | "findMany - should find many models with contains operator" | "findMany - should handle multiple where conditions with different operators" | "findMany - should find many models with contains operator (using symbol)" | "findMany - should find many models with eq operator" | "findMany - should find many models with ne operator" | "findMany - should find many models with ne operator on id field" | "findMany - should find many models with ne operator on _id field (MongoDB)" | "findMany - should handle ne operator with null value on id field" | "findMany - should handle in operator with null value in array" | "findMany - should find many models with gt operator" | "findMany - should find many models with gte operator" | "findMany - should find many models with lte operator" | "findMany - should find many models with lt operator" | "findMany - should find many models with in operator" | "findMany - should find many models with not_in operator" | "findMany - should find many models with sortBy" | "findMany - should find many models with limit" | "findMany - should find many models with offset" | "findMany - should find many models with limit and offset" | "findMany - should find many models with sortBy and offset" | "findMany - should find many models with sortBy and limit" | "findMany - should find many models with sortBy and limit and offset" | "findMany - should find many models with sortBy and limit and offset and where" | "update - should update a model" | "updateMany - should update all models when where is empty" | "updateMany - should update many models with a specific where" | "updateMany - should update many models with a multiple where" | "delete - should delete a model" | "delete - should not throw on record not found" | "deleteMany - should delete many models" | "deleteMany - starts_with should not interpret regex patterns" | "deleteMany - ends_with should not interpret regex patterns" | "deleteMany - contains should not interpret regex patterns" | "deleteMany - should delete many models with numeric values" | "deleteMany - should delete many models with boolean values" | "count - should count many models" | "count - should return 0 with no rows to count" | "count - should count with where clause" | "update - should correctly return record when updating a field used in where clause" | "update - should handle updating multiple fields including where clause field" | "update - should work when updated field is not in where clause", boolean> & {
+        ALL?: boolean;
+    }> | undefined;
+} | undefined) => (helpers: {
+    adapter: () => Promise<import("packages/core/dist/index-65G5U5DB.mjs").nt<import("@gatwech/core").PayvoAuthOptions>>;
+    log: import("../test-adapter").Logger;
+    adapterDisplayName: string;
+    getPayvoAuthOptions: () => import("@gatwech/core").PayvoAuthOptions;
+    modifyPayvoAuthOptions: (options: import("@gatwech/core").PayvoAuthOptions) => Promise<import("@gatwech/core").PayvoAuthOptions>;
+    cleanup: () => Promise<void>;
+    runMigrations: () => Promise<void>;
+    prefixTests?: string | undefined;
+    onTestFinish: () => Promise<void>;
+    customIdGenerator?: (() => any | Promise<any> | undefined) | undefined;
+    transformIdOutput?: ((id: any) => string | undefined) | undefined;
+}) => Promise<void>;
+export declare const getNormalTestSuiteTests: ({ adapter, generate, insertRandom, modifyPayvoAuthOptions, sortModels, customIdGenerator, getPayvoAuthOptions, transformGeneratedModel, transformIdOutput, }: Parameters<Parameters<typeof createTestSuite>[2]>[0]) => {
+    "create - should create a model": () => Promise<void>;
+    "create - should always return an id": () => Promise<void>;
+    "create - should use generateId if provided": () => Promise<void>;
+    "create - should return null for nullable foreign keys": () => Promise<void>;
+    "create - should apply default values to fields": () => Promise<void>;
+    "findOne - should find a model": () => Promise<void>;
+    "findOne - should not apply defaultValue if value not found": () => Promise<void>;
+    "findOne - should find a model using a reference field": () => Promise<void>;
+    "findOne - should not throw on record not found": () => Promise<void>;
+    "findOne - should find a model without id": () => Promise<void>;
+    "findOne - should find a model with modified field name": () => Promise<void>;
+    "findOne - should find a model with modified model name": () => Promise<void>;
+    "findOne - should find a model with additional fields": () => Promise<void>;
+    "findOne - should select fields": () => Promise<void>;
+    "findOne - should find model with date field": () => Promise<void>;
+    "findMany - should find many models with date fields": () => Promise<void>;
+    "findMany - should find many models": () => Promise<void>;
+    "findMany - should return an empty array when no models are found": () => Promise<void>;
+    "findMany - should find many models with starts_with operator": () => Promise<void>;
+    "findMany - starts_with should not interpret regex patterns": () => Promise<void>;
+    "findMany - ends_with should not interpret regex patterns": () => Promise<void>;
+    "findMany - contains should not interpret regex patterns": () => Promise<void>;
+    "findMany - should find many models with ends_with operator": () => Promise<void>;
+    "findMany - should find many models with contains operator": () => Promise<void>;
+    "findMany - should handle multiple where conditions with different operators": () => Promise<void>;
+    "findMany - should find many models with contains operator (using symbol)": () => Promise<void>;
+    "findMany - should find many models with eq operator": () => Promise<void>;
+    "findMany - should find many models with ne operator": () => Promise<void>;
+    "findMany - should find many models with ne operator on id field": () => Promise<void>;
+    "findMany - should find many models with ne operator on _id field (MongoDB)": () => Promise<void>;
+    "findMany - should handle ne operator with null value on id field": () => Promise<void>;
+    "findMany - should handle in operator with null value in array": () => Promise<void>;
+    "findMany - should find many models with gt operator": () => Promise<void>;
+    "findMany - should find many models with gte operator": () => Promise<void>;
+    "findMany - should find many models with lte operator": () => Promise<void>;
+    "findMany - should find many models with lt operator": () => Promise<void>;
+    "findMany - should find many models with in operator": () => Promise<void>;
+    "findMany - should find many models with not_in operator": () => Promise<void>;
+    "findMany - should find many models with sortBy": () => Promise<void>;
+    "findMany - should find many models with limit": () => Promise<void>;
+    "findMany - should find many models with offset": () => Promise<void>;
+    "findMany - should find many models with limit and offset": () => Promise<void>;
+    "findMany - should find many models with sortBy and offset": () => Promise<void>;
+    "findMany - should find many models with sortBy and limit": () => Promise<void>;
+    "findMany - should find many models with sortBy and limit and offset": () => Promise<void>;
+    "findMany - should find many models with sortBy and limit and offset and where": () => Promise<void>;
+    "update - should update a model": () => Promise<void>;
+    "updateMany - should update all models when where is empty": () => Promise<void>;
+    "updateMany - should update many models with a specific where": () => Promise<void>;
+    "updateMany - should update many models with a multiple where": () => Promise<void>;
+    "delete - should delete a model": () => Promise<void>;
+    "delete - should not throw on record not found": () => Promise<void>;
+    "deleteMany - should delete many models": () => Promise<void>;
+    "deleteMany - starts_with should not interpret regex patterns": () => Promise<void>;
+    "deleteMany - ends_with should not interpret regex patterns": () => Promise<void>;
+    "deleteMany - contains should not interpret regex patterns": () => Promise<void>;
+    "deleteMany - should delete many models with numeric values": () => Promise<void>;
+    "deleteMany - should delete many models with boolean values": () => Promise<void>;
+    "count - should count many models": () => Promise<void>;
+    "count - should return 0 with no rows to count": () => Promise<void>;
+    "count - should count with where clause": () => Promise<void>;
+    "update - should correctly return record when updating a field used in where clause": () => Promise<void>;
+    "update - should handle updating multiple fields including where clause field": () => Promise<void>;
+    "update - should work when updated field is not in where clause": () => Promise<void>;
+};