@vsrepo/drizzle-adapter 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,184 @@
+import { KeysOfType, Primitive, RelationKeys, VSRepoAdapter, VSRepoTransactionOptions, AdapterQueryOptions, VSRepoWhere, AdapterMethodOptions, DeepPartial, CountResult, NumericKeys } from 'vsrepo';
+import { SQLWrapper, Table } from 'drizzle-orm';
+
+/**
+ * @publicApi
+ */
+type DrizzleTransactionLike = DrizzleDbLike & {
+    rollback(): never;
+};
+
+type Fn = (...args: any[]) => any;
+/**
+ * @publicApi
+ */
+type DrizzleDbLike = {
+    select: Fn;
+    insert: Fn;
+    update: Fn;
+    delete: Fn;
+    query: Record<string, {
+        findFirst: Fn;
+        findMany: Fn;
+    }>;
+    selectDistinct: (fields: object) => {
+        from: (table: any) => any;
+    };
+    execute: (query: SQLWrapper) => Promise<any>;
+    transaction: <R>(fn: (tx: DrizzleTransactionLike) => Promise<R>, config?: any) => Promise<R>;
+};
+
+/**
+ * @publicApi
+ */
+type SupportedDialects = "postgresql" | "sqlite" | "cockroach";
+
+/**
+ * @publicApi
+ */
+type AdapterRelation<T, K> = {
+    restriction: "set" | "add";
+    table: Table;
+    fkHere?: KeysOfType<T, Primitive>;
+    fkThere?: KeysOfType<K, Primitive>;
+} & ({
+    mode: "otm";
+    fkThere: KeysOfType<K, Primitive>;
+    fkHere?: never;
+} | {
+    mode: "mto";
+    nullable?: boolean;
+    fkHere: KeysOfType<T, Primitive>;
+} | ({
+    mode: "oto";
+} & ({
+    fkHere: KeysOfType<T, Primitive>;
+    fkThere?: never;
+} | {
+    fkThere: KeysOfType<K, Primitive>;
+    fkHere?: never;
+})));
+
+/**
+ * @publicApi
+ */
+type AdapterRelations<T> = Partial<{
+    [P in RelationKeys<T>]: AdapterRelation<T, NonNullable<T[P]> extends Array<infer U> ? U : NonNullable<T[P]>>;
+}>;
+
+/**
+ * @publicApi
+ */
+type DrizzleAdapterConfig<T, K extends DrizzleDbLike = DrizzleDbLike> = {
+    table: Table;
+    dialect?: SupportedDialects;
+    queryKey: keyof K["query"];
+    relations?: AdapterRelations<T>;
+};
+
+/**
+ * @publicApi
+ */
+declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends VSRepoAdapter<T> {
+    private readonly table;
+    private readonly db;
+    private readonly dialect;
+    private readonly pk;
+    private readonly queryKey;
+    private readonly relations?;
+    constructor(db: K, config: DrizzleAdapterConfig<T, K>);
+    /**
+     * Returns `db.query[queryKey]` (the relational query builder entry for
+     * this adapter's table), reading from `db` when a transaction/executor
+     * override is passed via `options.db`, otherwise from the root client.
+     */
+    private getQueryBuilder;
+    /**
+     * Resolves the "read" part of a query arg: `columns`/`with`/`where`/
+     * `orderBy`/pagination.
+     *
+     * Per the adapter contract: when both `select` and `relations` are
+     * given, `select` wins and `relations` is ignored entirely.
+     */
+    private resolveReadArgs;
+    /** Builds the context `parseSqlWhere` needs to resolve `_with`/`_without`/`_some`/`_every`/`_none` relation filters. */
+    private getSqlWhereContext;
+    /**
+     * Resolves a user-supplied `VSRepoWhere<T>` into the `where` shape the
+     * relational query API (`db.query[queryKey].findFirst/findMany`) accepts.
+     *
+     * The relational API's own object-shaped `where` (`where.parser.ts`) has
+     * no native `_every`/`_none` semantics for to-many relations — so when
+     * `where` contains one (`hasQuantifierFilter`), this instead:
+     *  1. Resolves `where` into a `SQL` condition via `sql-where.parser.ts`
+     *     (which DOES support `_every`/`_none`, via `NOT EXISTS`);
+     *  2. Runs `db.select({pk}).from(table).where(condition)`, applying the
+     *     SAME `order`/`limit`/`offset` the final query would've used
+     *     (`sql-order-by.parser.ts`), so the prefetch only ever pulls the
+     *     rows the caller actually needs, instead of every matching row;
+     *  3. Returns `parseDrizzleWhere({ [pk]: { in: pks } })` instead — the
+     *     relational API then only has to filter by pk (trivial for it),
+     *     while still handling `columns`/`with` on the correct result set.
+     *
+     * Since SQL `IN (...)` doesn't preserve the given list's order, `resolveReadArgs`
+     * re-applies `orderBy` (but NOT `limit`/`offset`, already baked into the pk set)
+     * on the final relational query when `paginationApplied` comes back `true`.
+     *
+     * This keeps `_every`/`_none` support consistent between this adapter's
+     * two `where` parsers — from the outside, `findOne`/`findMany`/etc. never
+     * throw `NOT_SUPPORTED` for them, at the cost of an extra round-trip only
+     * when they're actually used.
+     */
+    private resolveFindWhere;
+    /**
+     * Strips relation fields from a payload — used by `createMany`/`updateMany`/
+     * `updateManyReturning`, since batch statements only accept flat column
+     * data (no nested writes). Throws `VSRepoAdapterError` (code
+     * `NOT_SUPPORTED`) instead of silently dropping the field, when a
+     * configured relation field is present in the payload.
+     */
+    private stripRelationFields;
+    private isRootClient;
+    private runTransactional;
+    runInTransaction<R>(fn: (tx: DrizzleTransactionLike) => Promise<R>, options?: VSRepoTransactionOptions): Promise<R>;
+    getDbClient(): DrizzleDbLike;
+    query<R = any>(rawQuery: string, options?: AdapterQueryOptions): Promise<R>;
+    findOne(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T | null>;
+    findOneOrThrow(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    findMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T> & {
+        distinct?: (keyof T)[];
+    }): Promise<T[]>;
+    save(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    saveMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T>): Promise<T[]>;
+    create(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    createMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
+        ignoreConflicts?: boolean;
+    }): Promise<CountResult>;
+    createManyReturning(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
+        ignoreConflicts?: boolean;
+    }): Promise<T[]>;
+    delete(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    deleteMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
+    deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+    update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
+    updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+    count(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number>;
+    exists(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<boolean>;
+    merge<K>(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<K & T>;
+    upsert(where: VSRepoWhere<T>, create: DeepPartial<T>, update: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /** Shared implementation behind `incrementOne`/`decrementOne`/`multiplyOne`/`divideOne`. */
+    private atomicUpdate;
+    incrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    decrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    multiplyOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    divideOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /** Shared implementation behind `sum`/`average`/`min`/`max`. */
+    private aggregate;
+    sum(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    average(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    min(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    max(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+}
+
+export { DrizzleAdapter, type DrizzleAdapterConfig, type DrizzleDbLike, type DrizzleTransactionLike, type SupportedDialects };