cloudflare-next-intl 0.8.0 → 0.8.2

package/README.md

@@ -523,7 +523,38 @@ const rows = await withPublicDb((db) => db.select().from(bonds).limit(10));
 helpers (`excluded`, `onConflictSet`, `ago`, `currentDate`, `windowCount`,
 `unnestLateral`, `ascNullsLast`, `alwaysTrue`, `lateral`, `aliasColumn`,
 `minOf`, `maxOf`, `roundReal`, `multiply`, `scalarFromCte`) for building
-upsert/window/lateral-join queries without dropping to raw SQL.
+upsert/window/lateral-join queries without dropping to raw SQL, plus a
+re-export of `drizzle-orm`'s common query-building primitives (`eq`, `and`,
+`or`, `asc`, `desc`, `gte`, `gt`, `lte`, `lt`, `isNull`, `isNotNull`, `count`,
+`sum`, `max`, `min`, `sql`) — so code that only builds queries against the
+`DrizzleDb` handle from `withPublicDb`/`withUserDb` doesn't need its own
+`drizzle-orm` import for these. Anything not listed here (schema definitions,
+`drizzle-orm/pg-core` column builders, relations) still comes from
+`drizzle-orm` directly — this package re-exports the query-operator surface
+only, not the whole library.
+
+#### Testing code that calls `withPublicDb`/`withUserDb`
+
+`cloudflare-next-intl/dbTesting` exports a fake `DrizzleDb` so repository/unit
+tests don't need a real Postgres connection:
+
+```typescript
+import { makeFakeDb, rowsResult } from "cloudflare-next-intl/dbTesting";
+
+const db = makeFakeDb([rowsResult([{ id: 1 }])]);
+const rows = await db.select().from(bonds).limit(10);
+// rows === [{ id: 1 }]
+```
+
+`makeFakeDb(results)` takes an ordered queue of `rowsResult(rows)` (for
+`select`/`insert`/`update`/`delete`) and `executeResult(rows)` (for
+`execute(...)`) entries, consumed one per terminal call in the exact order
+your code issues them. Every intermediate chain call (`.where(...)`,
+`.values(...)`, `.orderBy(...)`, etc.) is recorded with its exact arguments,
+inspectable via `db.calls[i].chain.argsOf('where')` — so a test can assert not
+just "select was called" but "the second select's `.where(...)` argument was
+X". Handles `db.$with(name).as(builder)` / `db.with(...).select(...)`
+CTE-style queries the same way the real Drizzle client does.
 
 ## License
 

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

@@ -1,4 +1,11 @@
-import { type SQL, type Table } from 'drizzle-orm';
+import { sql, eq, and, or, asc, desc, gte, gt, lte, lt, isNull, isNotNull, count, sum, max, min, type SQL, type Table } from 'drizzle-orm';
+/**
+ * Re-exported `drizzle-orm` query-building primitives, so code that only
+ * calls `withPublicDb`/`withUserDb` and builds queries against the returned
+ * `DrizzleDb` never needs its own `drizzle-orm` import for common predicates,
+ * ordering, and aggregates.
+ */
+export { eq, and, or, asc, desc, gte, gt, lte, lt, isNull, isNotNull, count, sum, max, min, sql };
 /**
  * Type-safe helper returning `excluded.<db_column_name>` SQL expressions for a Drizzle table.
  *

package/dist/src/db/helpers.js

@@ -1,4 +1,11 @@
-import { getTableColumns, getTableName, sql } from 'drizzle-orm';
+import { getTableColumns, getTableName, sql, eq, and, or, asc, desc, gte, gt, lte, lt, isNull, isNotNull, count, sum, max, min, } from 'drizzle-orm';
+/**
+ * Re-exported `drizzle-orm` query-building primitives, so code that only
+ * calls `withPublicDb`/`withUserDb` and builds queries against the returned
+ * `DrizzleDb` never needs its own `drizzle-orm` import for common predicates,
+ * ordering, and aggregates.
+ */
+export { eq, and, or, asc, desc, gte, gt, lte, lt, isNull, isNotNull, count, sum, max, min, sql };
 /**
  * Type-safe helper returning `excluded.<db_column_name>` SQL expressions for a Drizzle table.
  *

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

@@ -0,0 +1,115 @@
+/**
+ * Test double for {@link DrizzleDb} — the handle `withPublicDb`/`withUserDb`
+ * pass to your callback. Use it in repository/unit tests to avoid a real
+ * Postgres connection: build one with {@link makeFakeDb}, queue canned
+ * results with {@link rowsResult}/{@link executeResult}, then pass it
+ * directly wherever your code expects a `DrizzleDb`.
+ *
+ * Real repositories call chains like `db.select({...}).from(t).where(w)...`
+ * where every intermediate call returns `this` and the final awaited value
+ * resolves to a canned row array — plus `db.execute(sql...)` resolving to
+ * `{ rows: [...] }`, and `db.$with(name).as(builder)` / `db.with(...).select(...)`
+ * for CTE-based queries.
+ *
+ * Each fake db instance is given an ordered queue of results (`resultQueue`)
+ * consumed one-per-terminal-call in the exact sequence your code issues
+ * them — select/insert/update/delete/execute all share one queue, so call
+ * order in your source is what determines which fixture a call gets.
+ *
+ * Every intermediate chain call (`.where(...)`, `.values(...)`, `.set(...)`,
+ * `.orderBy(...)`, etc.) is also recorded with its exact arguments on the
+ * chain object returned from `select`/`insert`/`update`/`delete`, and that
+ * chain object is attached to the matching entry in `db.calls` — so a test
+ * can assert not just "select was called twice" but "the second select's
+ * `.where(...)` argument was X", closing the gap where a fake that only
+ * echoes canned rows back can't detect a broken predicate/sort/value.
+ */
+type Row = Record<string, unknown>;
+interface QueuedResult {
+    kind: 'rows' | 'execute';
+    rows: Row[];
+}
+/** Queues a result for a `select`/`insert`/`update`/`delete` chain. */
+declare function rowsResult(rows: Row[]): QueuedResult;
+/** Queues a result for an `execute(...)` call. */
+declare function executeResult(rows: Row[]): QueuedResult;
+interface ChainCall {
+    method: string;
+    args: unknown[];
+}
+/**
+ * Lazy like real drizzle query builders: intermediate calls just record
+ * themselves and return `this`; the queue is only consumed when the chain
+ * is actually awaited (`.then()`), which is also when a CTE built via
+ * `db.$with(name).as(builder)` is skipped — a CTE definition is never
+ * itself awaited standalone, only the final `db.with(...).select(...)`
+ * chain that references it is.
+ */
+declare class ChainableQuery implements PromiseLike<Row[]> {
+    private readonly takeRows;
+    /** Every intermediate call this chain received, in call order, with its exact arguments. */
+    readonly chainCalls: ChainCall[];
+    constructor(takeRows: () => Row[]);
+    private record;
+    /** Returns the arguments of this chain's first call to `method` (e.g. `"where"`, `"values"`). */
+    argsOf(method: string): unknown[] | undefined;
+    from(...args: unknown[]): this;
+    leftJoin(...args: unknown[]): this;
+    innerJoin(...args: unknown[]): this;
+    where(...args: unknown[]): this;
+    orderBy(...args: unknown[]): this;
+    groupBy(...args: unknown[]): this;
+    limit(...args: unknown[]): this;
+    offset(...args: unknown[]): this;
+    values(...args: unknown[]): this;
+    set(...args: unknown[]): this;
+    returning(...args: unknown[]): this;
+    as(...args: unknown[]): this;
+    then<TResult1 = Row[], TResult2 = never>(onfulfilled?: ((value: Row[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+}
+/**
+ * Fake {@link DrizzleDb} backed by a queue of canned results. Build one with
+ * {@link makeFakeDb} rather than calling this constructor directly.
+ */
+declare class FakeDrizzleDb {
+    private readonly queue;
+    /** Top-level calls captured for assertions — each entry's `chain` is the same `ChainableQuery` returned to the caller, so its recorded `.where()`/`.values()`/etc. arguments are inspectable via `chain.argsOf(...)`. */
+    readonly calls: {
+        method: string;
+        args: unknown[];
+        chain?: ChainableQuery;
+    }[];
+    constructor(queue: QueuedResult[]);
+    private takeRows;
+    private makeChain;
+    select(...args: unknown[]): ChainableQuery;
+    insert(...args: unknown[]): ChainableQuery;
+    update(...args: unknown[]): ChainableQuery;
+    delete(...args: unknown[]): ChainableQuery;
+    execute(...args: unknown[]): Promise<{
+        rows: Row[];
+    }>;
+    /** CTE definition — never awaited on its own, so it must not touch the queue. */
+    $with(_name: string): {
+        as: (builder: unknown) => unknown;
+    };
+    with(..._ctes: unknown[]): {
+        select: (...args: unknown[]) => ChainableQuery;
+    };
+}
+/**
+ * Builds a fake {@link DrizzleDb} that resolves each terminal call
+ * (`select`/`insert`/`update`/`delete`/`execute`) to the next entry in
+ * `results`, in the exact order your code under test calls them.
+ *
+ * @param results Queued results, one per terminal call, built with
+ * {@link rowsResult}/{@link executeResult}.
+ * @returns A fake db to pass wherever your code expects a `DrizzleDb`.
+ *
+ * @example
+ * const db = makeFakeDb([rowsResult([{ id: 1 }])]);
+ * const rows = await db.select().from(bonds);
+ */
+export declare function makeFakeDb(results: QueuedResult[]): FakeDrizzleDb;
+export { rowsResult, executeResult };
+export type { Row, ChainableQuery, FakeDrizzleDb };

package/dist/src/db/testing.js

@@ -0,0 +1,137 @@
+/**
+ * Test double for {@link DrizzleDb} — the handle `withPublicDb`/`withUserDb`
+ * pass to your callback. Use it in repository/unit tests to avoid a real
+ * Postgres connection: build one with {@link makeFakeDb}, queue canned
+ * results with {@link rowsResult}/{@link executeResult}, then pass it
+ * directly wherever your code expects a `DrizzleDb`.
+ *
+ * Real repositories call chains like `db.select({...}).from(t).where(w)...`
+ * where every intermediate call returns `this` and the final awaited value
+ * resolves to a canned row array — plus `db.execute(sql...)` resolving to
+ * `{ rows: [...] }`, and `db.$with(name).as(builder)` / `db.with(...).select(...)`
+ * for CTE-based queries.
+ *
+ * Each fake db instance is given an ordered queue of results (`resultQueue`)
+ * consumed one-per-terminal-call in the exact sequence your code issues
+ * them — select/insert/update/delete/execute all share one queue, so call
+ * order in your source is what determines which fixture a call gets.
+ *
+ * Every intermediate chain call (`.where(...)`, `.values(...)`, `.set(...)`,
+ * `.orderBy(...)`, etc.) is also recorded with its exact arguments on the
+ * chain object returned from `select`/`insert`/`update`/`delete`, and that
+ * chain object is attached to the matching entry in `db.calls` — so a test
+ * can assert not just "select was called twice" but "the second select's
+ * `.where(...)` argument was X", closing the gap where a fake that only
+ * echoes canned rows back can't detect a broken predicate/sort/value.
+ */
+/** Queues a result for a `select`/`insert`/`update`/`delete` chain. */
+function rowsResult(rows) {
+    return { kind: 'rows', rows };
+}
+/** Queues a result for an `execute(...)` call. */
+function executeResult(rows) {
+    return { kind: 'execute', rows };
+}
+/**
+ * Lazy like real drizzle query builders: intermediate calls just record
+ * themselves and return `this`; the queue is only consumed when the chain
+ * is actually awaited (`.then()`), which is also when a CTE built via
+ * `db.$with(name).as(builder)` is skipped — a CTE definition is never
+ * itself awaited standalone, only the final `db.with(...).select(...)`
+ * chain that references it is.
+ */
+class ChainableQuery {
+    constructor(takeRows) {
+        this.takeRows = takeRows;
+        /** Every intermediate call this chain received, in call order, with its exact arguments. */
+        this.chainCalls = [];
+    }
+    record(method, args) {
+        this.chainCalls.push({ method, args });
+        return this;
+    }
+    /** Returns the arguments of this chain's first call to `method` (e.g. `"where"`, `"values"`). */
+    argsOf(method) {
+        return this.chainCalls.find((c) => c.method === method)?.args;
+    }
+    from(...args) { return this.record('from', args); }
+    leftJoin(...args) { return this.record('leftJoin', args); }
+    innerJoin(...args) { return this.record('innerJoin', args); }
+    where(...args) { return this.record('where', args); }
+    orderBy(...args) { return this.record('orderBy', args); }
+    groupBy(...args) { return this.record('groupBy', args); }
+    limit(...args) { return this.record('limit', args); }
+    offset(...args) { return this.record('offset', args); }
+    values(...args) { return this.record('values', args); }
+    set(...args) { return this.record('set', args); }
+    returning(...args) { return this.record('returning', args); }
+    as(...args) { return this.record('as', args); }
+    then(onfulfilled, onrejected) {
+        return Promise.resolve().then(() => this.takeRows()).then(onfulfilled, onrejected);
+    }
+}
+/**
+ * Fake {@link DrizzleDb} backed by a queue of canned results. Build one with
+ * {@link makeFakeDb} rather than calling this constructor directly.
+ */
+class FakeDrizzleDb {
+    constructor(queue) {
+        /** Top-level calls captured for assertions — each entry's `chain` is the same `ChainableQuery` returned to the caller, so its recorded `.where()`/`.values()`/etc. arguments are inspectable via `chain.argsOf(...)`. */
+        this.calls = [];
+        this.queue = [...queue];
+    }
+    takeRows(method) {
+        const next = this.queue.shift();
+        if (!next)
+            throw new Error(`FakeDrizzleDb: no queued result left for ${method}()`);
+        return next.rows;
+    }
+    makeChain(method, args) {
+        const chain = new ChainableQuery(() => this.takeRows(method));
+        this.calls.push({ method, args, chain });
+        return chain;
+    }
+    select(...args) {
+        return this.makeChain('select', args);
+    }
+    insert(...args) {
+        return this.makeChain('insert', args);
+    }
+    update(...args) {
+        return this.makeChain('update', args);
+    }
+    delete(...args) {
+        return this.makeChain('delete', args);
+    }
+    async execute(...args) {
+        this.calls.push({ method: 'execute', args });
+        const next = this.queue.shift();
+        if (!next)
+            throw new Error('FakeDrizzleDb: no queued result left for execute()');
+        return { rows: next.rows };
+    }
+    /** CTE definition — never awaited on its own, so it must not touch the queue. */
+    $with(_name) {
+        return { as: (builder) => builder };
+    }
+    with(..._ctes) {
+        return { select: (...args) => this.select(...args) };
+    }
+}
+/**
+ * Builds a fake {@link DrizzleDb} that resolves each terminal call
+ * (`select`/`insert`/`update`/`delete`/`execute`) to the next entry in
+ * `results`, in the exact order your code under test calls them.
+ *
+ * @param results Queued results, one per terminal call, built with
+ * {@link rowsResult}/{@link executeResult}.
+ * @returns A fake db to pass wherever your code expects a `DrizzleDb`.
+ *
+ * @example
+ * const db = makeFakeDb([rowsResult([{ id: 1 }])]);
+ * const rows = await db.select().from(bonds);
+ */
+export function makeFakeDb(results) {
+    return new FakeDrizzleDb(results);
+}
+export { rowsResult, executeResult };

package/dist/src/index.d.ts

@@ -4,4 +4,3 @@ export * from './server';
 export * from './client';
 export * from './theme_switcher';
 export * from './types';
-export * from './db';

package/dist/src/index.js

@@ -4,4 +4,3 @@ export * from './server';
 export * from './client';
 export * from './theme_switcher';
 export * from './types';
-export * from './db';

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

@@ -1 +1 @@
-export type { CookieAttributes, LocalePrefixMode, Locales, ReturnType, RoutingConfig, TranslationEntry, TranslationObject, TranslatorReturnType, Alternates, changeFrequency, IntlSitemap, CookieConsentRoutingConfig, CookieConsentAnalyticsConfig, CookieConsentCloudflareContext, CookieConsentGetCloudflareContext, } from './types';
+export type { CookieAttributes, LocalePrefixMode, Locales, ReturnType, RoutingConfig, TranslationEntry, TranslationObject, TranslatorReturnType, Alternates, changeFrequency, IntlSitemap, CookieConsentRoutingConfig, CookieConsentAnalyticsConfig, CookieConsentCloudflareContext, CookieConsentGetCloudflareContext, DbRoutingConfig, SupabaseDbConfig, } from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -184,6 +184,10 @@
     "./dbHelpers": {
       "types": "./dist/src/db/helpers.d.ts",
       "import": "./dist/src/db/helpers.js"
+    },
+    "./dbTesting": {
+      "types": "./dist/src/db/testing.d.ts",
+      "import": "./dist/src/db/testing.js"
     }
   },
   "scripts": {