@smonn/ids 0.15.0 → 1.0.0-rc.1

package/dist/drizzle.d.mts

@@ -2,10 +2,23 @@ import { t as Id } from "./types-hGBnCpJj.mjs";
 import { n as IdColumnCodec } from "./adapter-types-Bia_w9sg.mjs";
 import { n as IdsErrorCode, r as isIdsError, t as IdsError } from "./error-CifcKKOG.mjs";
 import { ConvertCustomConfig, PgCustomColumnBuilder } from "drizzle-orm/pg-core";
+import { ConvertCustomConfig as ConvertCustomConfig$1, MySqlCustomColumnBuilder } from "drizzle-orm/mysql-core";
+import { ConvertCustomConfig as ConvertCustomConfig$2, SQLiteCustomColumnBuilder } from "drizzle-orm/sqlite-core";
+import { HasDefault, HasRuntimeDefault } from "drizzle-orm/column-builder";
 
 //#region src/adapters/drizzle.d.ts
 /**
-* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value.
+* Extension of {@link IdColumnCodec} that also exposes synchronous `generate()`.
+* Required by the `generatedIdColumn` family so that Drizzle's `.$defaultFn` can
+* produce IDs at write time without explicit call-site wiring. Only the **Timestamp
+* codec** and **Reverse Timestamp codec** satisfy this; async-generate codecs
+* (Opaque, Signed, Wrapped, Digest) do not and are a compile-time error.
+*/
+type IdGeneratingCodec<Brand extends string> = IdColumnCodec<Brand> & {
+  generate(): Id<Brand>;
+};
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value in PostgreSQL.
 *
 * **Write path:** passes the `Id<Brand>` directly to the driver — it is already
 * the canonical string form.
@@ -15,20 +28,206 @@ import { ConvertCustomConfig, PgCustomColumnBuilder } from "drizzle-orm/pg-core"
 * is a safe boundary in case stale non-canonical values exist. Throws if the
 * value from the database does not parse as a valid `Id<Brand>`.
 *
+* @param codec - The brand-scoped codec used to parse values read from the database.
+* @param options - Optional column configuration.
+* @param options.columnType - SQL column type to use (default: `"text"`). Pass
+*   `"varchar(30)"` or `"char(26)"` to match an existing DDL or index strategy.
+*   The value is passed through verbatim — no validation is performed.
+*
 * @example
 * ```ts
 * import { idColumn } from "@smonn/ids/drizzle";
 * import { createTimestampId } from "@smonn/ids";
 *
 * const usr = createTimestampId("usr");
+* // default: text column
 * export const users = pgTable("users", { id: idColumn(usr).primaryKey() });
+* // explicit varchar column
+* export const orgs = pgTable("orgs", { id: idColumn(usr, { columnType: "varchar(30)" }).primaryKey() });
+* ```
+*/
+declare function idColumn<Brand extends string>(codec: IdColumnCodec<Brand>, options?: {
+  columnType?: string;
+}): PgCustomColumnBuilder<ConvertCustomConfig<"", {
+  data: Id<Brand>;
+  driverData: string;
+}>>;
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in MySQL.
+*
+* **Write path:** passes the `Id<Brand>` directly to the driver — it is already
+* the canonical string form.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict
+* `is()`. Throws `IdsError("invalid_id")` if the value from the database does not
+* parse as a valid `Id<Brand>`.
+*
+* @example
+* ```ts
+* import { idColumnMysql } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = mysqlTable("users", { id: idColumnMysql(usr).primaryKey() });
 * // users.id is Id<"usr"> end-to-end
 * ```
 */
-declare function idColumn<Brand extends string>(codec: IdColumnCodec<Brand>): PgCustomColumnBuilder<ConvertCustomConfig<"", {
+declare function idColumnMysql<Brand extends string>(codec: IdColumnCodec<Brand>): MySqlCustomColumnBuilder<ConvertCustomConfig$1<"", {
   data: Id<Brand>;
   driverData: string;
 }>>;
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in SQLite.
+*
+* **Write path:** passes the `Id<Brand>` directly to the driver — it is already
+* the canonical string form.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict
+* `is()`. Throws `IdsError("invalid_id")` if the value from the database does not
+* parse as a valid `Id<Brand>`.
+*
+* @example
+* ```ts
+* import { idColumnSqlite } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = sqliteTable("users", { id: idColumnSqlite(usr).primaryKey() });
+* // users.id is Id<"usr"> end-to-end
+* ```
+*/
+declare function idColumnSqlite<Brand extends string>(codec: IdColumnCodec<Brand>): SQLiteCustomColumnBuilder<ConvertCustomConfig$2<"", {
+  data: Id<Brand>;
+  driverData: string;
+}>>;
+/**
+* Drizzle custom column type for a **nullable** `Id<Brand>` column.
+*
+* Behaves identically to {@link idColumn} except that `null` and `undefined`
+* driver values are passed through as `null` rather than throwing. Use for
+* optional foreign keys, `LEFT JOIN` results, and any column that is
+* legitimately absent.
+*
+* @example
+* ```ts
+* import { nullableIdColumn } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const posts = pgTable("posts", {
+*   authorId: nullableIdColumn(usr),
+* });
+* // posts.authorId is Id<"usr"> | null end-to-end
+* ```
+*/
+declare function nullableIdColumn<Brand extends string>(codec: IdColumnCodec<Brand>): PgCustomColumnBuilder<ConvertCustomConfig<"", {
+  data: Id<Brand> | null;
+  driverData: string | null;
+}>>;
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value
+* in PostgreSQL, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+* @param options - Optional column configuration.
+* @param options.columnType - SQL column type to use (default: `"text"`). Pass
+*   `"varchar(30)"` or `"char(26)"` to match an existing DDL or index strategy.
+*   The value is passed through verbatim — no validation is performed.
+*
+* @example
+* ```ts
+* import { generatedIdColumn } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = pgTable("users", { id: generatedIdColumn(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+declare function generatedIdColumn<Brand extends string>(codec: IdGeneratingCodec<Brand>, options?: {
+  columnType?: string;
+}): HasRuntimeDefault<HasDefault<PgCustomColumnBuilder<ConvertCustomConfig<"", {
+  data: Id<Brand>;
+  driverData: string;
+}>>>>;
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value
+* in MySQL, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+*   Column type is always `text` and cannot be overridden.
+*
+* @example
+* ```ts
+* import { generatedIdColumnMysql } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = mysqlTable("users", { id: generatedIdColumnMysql(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+declare function generatedIdColumnMysql<Brand extends string>(codec: IdGeneratingCodec<Brand>): HasRuntimeDefault<HasDefault<MySqlCustomColumnBuilder<ConvertCustomConfig$1<"", {
+  data: Id<Brand>;
+  driverData: string;
+}>>>>;
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value
+* in SQLite, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+*   Column type is always `text` and cannot be overridden.
+*
+* @example
+* ```ts
+* import { generatedIdColumnSqlite } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = sqliteTable("users", { id: generatedIdColumnSqlite(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+declare function generatedIdColumnSqlite<Brand extends string>(codec: IdGeneratingCodec<Brand>): HasRuntimeDefault<HasDefault<SQLiteCustomColumnBuilder<ConvertCustomConfig$2<"", {
+  data: Id<Brand>;
+  driverData: string;
+}>>>>;
 //#endregion
-export { type IdColumnCodec, IdsError, type IdsErrorCode, idColumn, isIdsError };
+export { type IdColumnCodec, IdGeneratingCodec, IdsError, type IdsErrorCode, generatedIdColumn, generatedIdColumnMysql, generatedIdColumnSqlite, idColumn, idColumnMysql, idColumnSqlite, isIdsError, nullableIdColumn };
 //# sourceMappingURL=drizzle.d.mts.map

package/dist/drizzle.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle.d.mts","names":[],"sources":["../src/adapters/drizzle.ts"],"mappings":";;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,QAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,IACpB,qBAAA,CAAsB,mBAAA;EAA0B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA"}
+{"version":3,"file":"drizzle.d.mts","names":[],"sources":["../src/adapters/drizzle.ts"],"mappings":";;;;;;;;;AA+BA;;;;;;;AAAA,KAAY,iBAAA,yBAA0C,aAAA,CAAc,KAAA;EAClE,QAAA,IAAY,EAAA,CAAG,KAAA;AAAA;;;;;;;AAAA;AAgCjB;;;;;;;;;;;;;;;;;;;;;;iBAAgB,QAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,GACrB,OAAA;EAAY,UAAA;AAAA,IACX,qBAAA,CAAsB,mBAAA;EAA0B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;AAqCQ;iBAF5D,aAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,IACpB,wBAAA,CAAyB,qBAAA;EAA+B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;;;AAqCzB;AAmCnD;iBAtCgB,cAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,IACpB,yBAAA,CACD,qBAAA;EAAgC,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;;AAsCC;AA+CpD;;iBAlDgB,gBAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,IACpB,qBAAA,CACD,mBAAA;EAA0B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAe,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAoDiB;AA8CrE;;;;;;;;;iBAnDgB,iBAAA,uBACd,KAAA,EAAO,iBAAA,CAAkB,KAAA,GACzB,OAAA;EAAY,UAAA;AAAA,IACX,iBAAA,CACD,UAAA,CACE,qBAAA,CAAsB,mBAAA;EAA0B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA;;;;;;;;;;;;AAkDQ;AA6C7E;;;;;;;;;;;;;;;;;iBAjDgB,sBAAA,uBACd,KAAA,EAAO,iBAAA,CAAkB,KAAA,IACxB,iBAAA,CACD,UAAA,CACE,wBAAA,CAAyB,qBAAA;EAA+B,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA;;;;;;AAkDtB;;;;;;;;;;;;;;;;;;;;;;;;iBALvC,uBAAA,uBACd,KAAA,EAAO,iBAAA,CAAkB,KAAA,IACxB,iBAAA,CACD,UAAA,CACE,yBAAA,CACE,qBAAA;EAAgC,IAAA,EAAM,EAAA,CAAG,KAAA;EAAQ,UAAA;AAAA"}

package/dist/drizzle.mjs

@@ -1,9 +1,11 @@
 import { n as isIdsError, t as IdsError } from "./error-Cp5qYZcv.mjs";
-import { t as readIdColumn } from "./adapter-types-7wWdELSh.mjs";
+import { n as readIdColumnNullable, t as readIdColumn } from "./adapter-types-CjzFNDcJ.mjs";
 import { customType } from "drizzle-orm/pg-core";
+import { customType as customType$1 } from "drizzle-orm/mysql-core";
+import { customType as customType$2 } from "drizzle-orm/sqlite-core";
 //#region src/adapters/drizzle.ts
 /**
-* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value.
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value in PostgreSQL.
 *
 * **Write path:** passes the `Id<Brand>` directly to the driver — it is already
 * the canonical string form.
@@ -13,18 +15,93 @@ import { customType } from "drizzle-orm/pg-core";
 * is a safe boundary in case stale non-canonical values exist. Throws if the
 * value from the database does not parse as a valid `Id<Brand>`.
 *
+* @param codec - The brand-scoped codec used to parse values read from the database.
+* @param options - Optional column configuration.
+* @param options.columnType - SQL column type to use (default: `"text"`). Pass
+*   `"varchar(30)"` or `"char(26)"` to match an existing DDL or index strategy.
+*   The value is passed through verbatim — no validation is performed.
+*
 * @example
 * ```ts
 * import { idColumn } from "@smonn/ids/drizzle";
 * import { createTimestampId } from "@smonn/ids";
 *
 * const usr = createTimestampId("usr");
+* // default: text column
 * export const users = pgTable("users", { id: idColumn(usr).primaryKey() });
-* // users.id is Id<"usr"> end-to-end
+* // explicit varchar column
+* export const orgs = pgTable("orgs", { id: idColumn(usr, { columnType: "varchar(30)" }).primaryKey() });
 * ```
 */
-function idColumn(codec) {
+function idColumn(codec, options) {
+	const columnType = options?.columnType ?? "text";
 	return customType({
+		dataType() {
+			return columnType;
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumn(codec, value);
+		}
+	})();
+}
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in MySQL.
+*
+* **Write path:** passes the `Id<Brand>` directly to the driver — it is already
+* the canonical string form.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict
+* `is()`. Throws `IdsError("invalid_id")` if the value from the database does not
+* parse as a valid `Id<Brand>`.
+*
+* @example
+* ```ts
+* import { idColumnMysql } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = mysqlTable("users", { id: idColumnMysql(usr).primaryKey() });
+* // users.id is Id<"usr"> end-to-end
+* ```
+*/
+function idColumnMysql(codec) {
+	return customType$1({
+		dataType() {
+			return "text";
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumn(codec, value);
+		}
+	})();
+}
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in SQLite.
+*
+* **Write path:** passes the `Id<Brand>` directly to the driver — it is already
+* the canonical string form.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict
+* `is()`. Throws `IdsError("invalid_id")` if the value from the database does not
+* parse as a valid `Id<Brand>`.
+*
+* @example
+* ```ts
+* import { idColumnSqlite } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = sqliteTable("users", { id: idColumnSqlite(usr).primaryKey() });
+* // users.id is Id<"usr"> end-to-end
+* ```
+*/
+function idColumnSqlite(codec) {
+	return customType$2({
 		dataType() {
 			return "text";
 		},
@@ -36,7 +113,170 @@ function idColumn(codec) {
 		}
 	})();
 }
+/**
+* Drizzle custom column type for a **nullable** `Id<Brand>` column.
+*
+* Behaves identically to {@link idColumn} except that `null` and `undefined`
+* driver values are passed through as `null` rather than throwing. Use for
+* optional foreign keys, `LEFT JOIN` results, and any column that is
+* legitimately absent.
+*
+* @example
+* ```ts
+* import { nullableIdColumn } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const posts = pgTable("posts", {
+*   authorId: nullableIdColumn(usr),
+* });
+* // posts.authorId is Id<"usr"> | null end-to-end
+* ```
+*/
+function nullableIdColumn(codec) {
+	return customType({
+		dataType() {
+			return "text";
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumnNullable(codec, value);
+		}
+	})();
+}
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value
+* in PostgreSQL, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+* @param options - Optional column configuration.
+* @param options.columnType - SQL column type to use (default: `"text"`). Pass
+*   `"varchar(30)"` or `"char(26)"` to match an existing DDL or index strategy.
+*   The value is passed through verbatim — no validation is performed.
+*
+* @example
+* ```ts
+* import { generatedIdColumn } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = pgTable("users", { id: generatedIdColumn(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+function generatedIdColumn(codec, options) {
+	const columnType = options?.columnType ?? "text";
+	return customType({
+		dataType() {
+			return columnType;
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumn(codec, value);
+		}
+	})().$defaultFn(() => codec.generate());
+}
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value
+* in MySQL, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+*   Column type is always `text` and cannot be overridden.
+*
+* @example
+* ```ts
+* import { generatedIdColumnMysql } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = mysqlTable("users", { id: generatedIdColumnMysql(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+function generatedIdColumnMysql(codec) {
+	return customType$1({
+		dataType() {
+			return "text";
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumn(codec, value);
+		}
+	})().$defaultFn(() => codec.generate());
+}
+/**
+* Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value
+* in SQLite, with a client-side `.$defaultFn` so inserts that omit the field receive
+* a freshly generated ID automatically.
+*
+* **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent
+* on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.
+*
+* **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.
+* Throws `IdsError("invalid_id")` if the value from the database does not parse as a
+* valid `Id<Brand>`.
+*
+* Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.
+* Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,
+* Wrapped, and Digest codecs are a compile-time error.
+*
+* @param codec - The brand-scoped codec used to generate and parse values.
+*   Column type is always `text` and cannot be overridden.
+*
+* @example
+* ```ts
+* import { generatedIdColumnSqlite } from "@smonn/ids/drizzle";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* export const users = sqliteTable("users", { id: generatedIdColumnSqlite(usr).primaryKey() });
+* // id is auto-filled on insert — no hand-supplied id needed
+* ```
+*/
+function generatedIdColumnSqlite(codec) {
+	return customType$2({
+		dataType() {
+			return "text";
+		},
+		toDriver(value) {
+			return value;
+		},
+		fromDriver(value) {
+			return readIdColumn(codec, value);
+		}
+	})().$defaultFn(() => codec.generate());
+}
 //#endregion
-export { IdsError, idColumn, isIdsError };
+export { IdsError, generatedIdColumn, generatedIdColumnMysql, generatedIdColumnSqlite, idColumn, idColumnMysql, idColumnSqlite, isIdsError, nullableIdColumn };
 
 //# sourceMappingURL=drizzle.mjs.map

package/dist/drizzle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle.mjs","names":[],"sources":["../src/adapters/drizzle.ts"],"sourcesContent":["import {\n  customType,\n  type ConvertCustomConfig,\n  type PgCustomColumnBuilder,\n} from \"drizzle-orm/pg-core\";\nimport { readIdColumn, type IdColumnCodec } from \"./adapter-types.js\";\nimport type { Id } from \"../types.js\";\n\n/** {@link IdsError} class, {@link isIdsError} type guard, and {@link IdsErrorCode} union — re-exported from `\"@smonn/ids\"` for convenience. */\nexport { IdsError, isIdsError, type IdsErrorCode } from \"../error.js\";\n\nexport type { IdColumnCodec };\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value.\n *\n * **Write path:** passes the `Id<Brand>` directly to the driver — it is already\n * the canonical string form.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict\n * `is()`. Data at rest should already be canonical per ADR-0003, but `safeParse`\n * is a safe boundary in case stale non-canonical values exist. Throws if the\n * value from the database does not parse as a valid `Id<Brand>`.\n *\n * @example\n * ```ts\n * import { idColumn } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = pgTable(\"users\", { id: idColumn(usr).primaryKey() });\n * // users.id is Id<\"usr\"> end-to-end\n * ```\n */\nexport function idColumn<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n): PgCustomColumnBuilder<ConvertCustomConfig<\"\", { data: Id<Brand>; driverData: string }>> {\n  return customType<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,SACd,OACyF;CACzF,OAAO,WAAoD;EACzD,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC;AACL"}
+{"version":3,"file":"drizzle.mjs","names":["customTypeMysql","customTypeSqlite"],"sources":["../src/adapters/drizzle.ts"],"sourcesContent":["import {\n  customType,\n  type ConvertCustomConfig,\n  type PgCustomColumnBuilder,\n} from \"drizzle-orm/pg-core\";\nimport {\n  customType as customTypeMysql,\n  type ConvertCustomConfig as ConvertCustomConfigMysql,\n  type MySqlCustomColumnBuilder,\n} from \"drizzle-orm/mysql-core\";\nimport {\n  customType as customTypeSqlite,\n  type ConvertCustomConfig as ConvertCustomConfigSqlite,\n  type SQLiteCustomColumnBuilder,\n} from \"drizzle-orm/sqlite-core\";\nimport type { HasDefault, HasRuntimeDefault } from \"drizzle-orm/column-builder\";\nimport { readIdColumn, readIdColumnNullable, type IdColumnCodec } from \"./adapter-types.js\";\nimport type { Id } from \"../types.js\";\n\n/** {@link IdsError} class, {@link isIdsError} type guard, and {@link IdsErrorCode} union — re-exported from `\"@smonn/ids\"` for convenience. */\nexport { IdsError, isIdsError, type IdsErrorCode } from \"../error.js\";\n\nexport type { IdColumnCodec };\n\n/**\n * Extension of {@link IdColumnCodec} that also exposes synchronous `generate()`.\n * Required by the `generatedIdColumn` family so that Drizzle's `.$defaultFn` can\n * produce IDs at write time without explicit call-site wiring. Only the **Timestamp\n * codec** and **Reverse Timestamp codec** satisfy this; async-generate codecs\n * (Opaque, Signed, Wrapped, Digest) do not and are a compile-time error.\n */\nexport type IdGeneratingCodec<Brand extends string> = IdColumnCodec<Brand> & {\n  generate(): Id<Brand>;\n};\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value in PostgreSQL.\n *\n * **Write path:** passes the `Id<Brand>` directly to the driver — it is already\n * the canonical string form.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict\n * `is()`. Data at rest should already be canonical per ADR-0003, but `safeParse`\n * is a safe boundary in case stale non-canonical values exist. Throws if the\n * value from the database does not parse as a valid `Id<Brand>`.\n *\n * @param codec - The brand-scoped codec used to parse values read from the database.\n * @param options - Optional column configuration.\n * @param options.columnType - SQL column type to use (default: `\"text\"`). Pass\n *   `\"varchar(30)\"` or `\"char(26)\"` to match an existing DDL or index strategy.\n *   The value is passed through verbatim — no validation is performed.\n *\n * @example\n * ```ts\n * import { idColumn } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * // default: text column\n * export const users = pgTable(\"users\", { id: idColumn(usr).primaryKey() });\n * // explicit varchar column\n * export const orgs = pgTable(\"orgs\", { id: idColumn(usr, { columnType: \"varchar(30)\" }).primaryKey() });\n * ```\n */\nexport function idColumn<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n  options?: { columnType?: string },\n): PgCustomColumnBuilder<ConvertCustomConfig<\"\", { data: Id<Brand>; driverData: string }>> {\n  const columnType = options?.columnType ?? \"text\";\n  return customType<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return columnType;\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })();\n}\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in MySQL.\n *\n * **Write path:** passes the `Id<Brand>` directly to the driver — it is already\n * the canonical string form.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict\n * `is()`. Throws `IdsError(\"invalid_id\")` if the value from the database does not\n * parse as a valid `Id<Brand>`.\n *\n * @example\n * ```ts\n * import { idColumnMysql } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = mysqlTable(\"users\", { id: idColumnMysql(usr).primaryKey() });\n * // users.id is Id<\"usr\"> end-to-end\n * ```\n */\nexport function idColumnMysql<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n): MySqlCustomColumnBuilder<ConvertCustomConfigMysql<\"\", { data: Id<Brand>; driverData: string }>> {\n  return customTypeMysql<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })();\n}\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value in SQLite.\n *\n * **Write path:** passes the `Id<Brand>` directly to the driver — it is already\n * the canonical string form.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict\n * `is()`. Throws `IdsError(\"invalid_id\")` if the value from the database does not\n * parse as a valid `Id<Brand>`.\n *\n * @example\n * ```ts\n * import { idColumnSqlite } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = sqliteTable(\"users\", { id: idColumnSqlite(usr).primaryKey() });\n * // users.id is Id<\"usr\"> end-to-end\n * ```\n */\nexport function idColumnSqlite<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n): SQLiteCustomColumnBuilder<\n  ConvertCustomConfigSqlite<\"\", { data: Id<Brand>; driverData: string }>\n> {\n  return customTypeSqlite<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })();\n}\n\n/**\n * Drizzle custom column type for a **nullable** `Id<Brand>` column.\n *\n * Behaves identically to {@link idColumn} except that `null` and `undefined`\n * driver values are passed through as `null` rather than throwing. Use for\n * optional foreign keys, `LEFT JOIN` results, and any column that is\n * legitimately absent.\n *\n * @example\n * ```ts\n * import { nullableIdColumn } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const posts = pgTable(\"posts\", {\n *   authorId: nullableIdColumn(usr),\n * });\n * // posts.authorId is Id<\"usr\"> | null end-to-end\n * ```\n */\nexport function nullableIdColumn<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n): PgCustomColumnBuilder<\n  ConvertCustomConfig<\"\", { data: Id<Brand> | null; driverData: string | null }>\n> {\n  return customType<{ data: Id<Brand> | null; driverData: string | null }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand> | null): string | null {\n      return value;\n    },\n    fromDriver(value: string | null): Id<Brand> | null {\n      return readIdColumnNullable(codec, value);\n    },\n  })();\n}\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical SQL string value\n * in PostgreSQL, with a client-side `.$defaultFn` so inserts that omit the field receive\n * a freshly generated ID automatically.\n *\n * **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent\n * on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.\n * Throws `IdsError(\"invalid_id\")` if the value from the database does not parse as a\n * valid `Id<Brand>`.\n *\n * Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.\n * Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,\n * Wrapped, and Digest codecs are a compile-time error.\n *\n * @param codec - The brand-scoped codec used to generate and parse values.\n * @param options - Optional column configuration.\n * @param options.columnType - SQL column type to use (default: `\"text\"`). Pass\n *   `\"varchar(30)\"` or `\"char(26)\"` to match an existing DDL or index strategy.\n *   The value is passed through verbatim — no validation is performed.\n *\n * @example\n * ```ts\n * import { generatedIdColumn } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = pgTable(\"users\", { id: generatedIdColumn(usr).primaryKey() });\n * // id is auto-filled on insert — no hand-supplied id needed\n * ```\n */\nexport function generatedIdColumn<Brand extends string>(\n  codec: IdGeneratingCodec<Brand>,\n  options?: { columnType?: string },\n): HasRuntimeDefault<\n  HasDefault<\n    PgCustomColumnBuilder<ConvertCustomConfig<\"\", { data: Id<Brand>; driverData: string }>>\n  >\n> {\n  const columnType = options?.columnType ?? \"text\";\n  return customType<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return columnType;\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })().$defaultFn(() => codec.generate());\n}\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value\n * in MySQL, with a client-side `.$defaultFn` so inserts that omit the field receive\n * a freshly generated ID automatically.\n *\n * **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent\n * on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.\n * Throws `IdsError(\"invalid_id\")` if the value from the database does not parse as a\n * valid `Id<Brand>`.\n *\n * Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.\n * Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,\n * Wrapped, and Digest codecs are a compile-time error.\n *\n * @param codec - The brand-scoped codec used to generate and parse values.\n *   Column type is always `text` and cannot be overridden.\n *\n * @example\n * ```ts\n * import { generatedIdColumnMysql } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = mysqlTable(\"users\", { id: generatedIdColumnMysql(usr).primaryKey() });\n * // id is auto-filled on insert — no hand-supplied id needed\n * ```\n */\nexport function generatedIdColumnMysql<Brand extends string>(\n  codec: IdGeneratingCodec<Brand>,\n): HasRuntimeDefault<\n  HasDefault<\n    MySqlCustomColumnBuilder<ConvertCustomConfigMysql<\"\", { data: Id<Brand>; driverData: string }>>\n  >\n> {\n  return customTypeMysql<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })().$defaultFn(() => codec.generate());\n}\n\n/**\n * Drizzle custom column type that stores an `Id<Brand>` as a canonical `text` value\n * in SQLite, with a client-side `.$defaultFn` so inserts that omit the field receive\n * a freshly generated ID automatically.\n *\n * **Write path:** `.$defaultFn(() => codec.generate())` is wired — if the field is absent\n * on insert, Drizzle calls `codec.generate()` to produce a new `Id<Brand>`.\n *\n * **Read path:** normalises the raw DB string via `codec.safeParse()`, not strict `is()`.\n * Throws `IdsError(\"invalid_id\")` if the value from the database does not parse as a\n * valid `Id<Brand>`.\n *\n * Requires a codec that exposes synchronous `generate()` — see {@link IdGeneratingCodec}.\n * Only the **Timestamp codec** and **Reverse Timestamp codec** qualify; Opaque, Signed,\n * Wrapped, and Digest codecs are a compile-time error.\n *\n * @param codec - The brand-scoped codec used to generate and parse values.\n *   Column type is always `text` and cannot be overridden.\n *\n * @example\n * ```ts\n * import { generatedIdColumnSqlite } from \"@smonn/ids/drizzle\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * export const users = sqliteTable(\"users\", { id: generatedIdColumnSqlite(usr).primaryKey() });\n * // id is auto-filled on insert — no hand-supplied id needed\n * ```\n */\nexport function generatedIdColumnSqlite<Brand extends string>(\n  codec: IdGeneratingCodec<Brand>,\n): HasRuntimeDefault<\n  HasDefault<\n    SQLiteCustomColumnBuilder<\n      ConvertCustomConfigSqlite<\"\", { data: Id<Brand>; driverData: string }>\n    >\n  >\n> {\n  return customTypeSqlite<{ data: Id<Brand>; driverData: string }>({\n    dataType() {\n      return \"text\";\n    },\n    toDriver(value: Id<Brand>): string {\n      return value;\n    },\n    fromDriver(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  })().$defaultFn(() => codec.generate());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,SAAgB,SACd,OACA,SACyF;CACzF,MAAM,aAAa,SAAS,cAAc;CAC1C,OAAO,WAAoD;EACzD,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,cACd,OACiG;CACjG,OAAOA,aAAyD;EAC9D,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,eACd,OAGA;CACA,OAAOC,aAA0D;EAC/D,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBACd,OAGA;CACA,OAAO,WAAkE;EACvE,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAAwC;GAC/C,OAAO;EACT;EACA,WAAW,OAAwC;GACjD,OAAO,qBAAqB,OAAO,KAAK;EAC1C;CACF,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,kBACd,OACA,SAKA;CACA,MAAM,aAAa,SAAS,cAAc;CAC1C,OAAO,WAAoD;EACzD,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,MAAM,SAAS,CAAC;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,uBACd,OAKA;CACA,OAAOD,aAAyD;EAC9D,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,MAAM,SAAS,CAAC;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,wBACd,OAOA;CACA,OAAOC,aAA0D;EAC/D,WAAW;GACT,OAAO;EACT;EACA,SAAS,OAA0B;GACjC,OAAO;EACT;EACA,WAAW,OAA0B;GACnC,OAAO,aAAa,OAAO,KAAK;EAClC;CACF,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,MAAM,SAAS,CAAC;AACxC"}

package/dist/express.d.mts

@@ -12,7 +12,7 @@ declare class IdParamError extends Error {
   readonly reason: "brand_mismatch" | "malformed";
   constructor(reason: "brand_mismatch" | "malformed", status: number);
 }
-/** Options for `idParam`. All fields are optional. */
+/** Options for `idParam` and `idQuery`. All fields are optional. */
 type IdParamOptions = {
   /**
   * Called instead of forwarding to `next(err)` when provided. The hook owns the response
@@ -77,6 +77,48 @@ type IdParamOptions = {
 * ```
 */
 declare function idParam<ParamKey extends string, Brand extends string>(paramName: ParamKey, codec: IdCodec<Brand>, options?: IdParamOptions): (req: Request, res: Response<unknown, Record<ParamKey, Id<Brand>>>, next: NextFunction) => void;
+/**
+* Express middleware that validates a named query-string param against a codec via `safeParse`.
+*
+* Same failure contract as `idParam` — same `IdParamOptions` / `IdParamFailure` shape, same
+* `IdParamError` forwarded to `next(err)` — but reads `req.query[queryName]` instead of
+* `req.params[queryName]`.
+*
+* **Default (no options):** calls `next(err)` with an `IdParamError` carrying `status` and
+* `reason`, so the app's existing error-handling middleware controls rendering. The adapter
+* does not write a response body itself.
+*
+* **`options.onError`:** when provided, the hook owns the response entirely — the adapter does
+* not call `next(err)`.
+*
+* **`options.status`:** remaps the default HTTP status for a reason without a full handler.
+*
+* - **Brand mismatch (`invalid_prefix`) → `reason: "brand_mismatch"`, default 404**
+* - **Malformed or missing query param → `reason: "malformed"`, default 400**
+*
+* On success, stores the canonical `Id<Brand>` in `res.locals` under `queryName`
+* and calls `next()`.
+*
+* @example
+* ```ts
+* import { idQuery, IdParamError } from "@smonn/ids/express";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+*
+* // Default: forwards error to app error-handling middleware
+* // GET /users?userId=usr_...
+* app.get("/users", idQuery("userId", usr), (req, res) => {
+*   const userId = res.locals.userId; // Id<"usr">, canonical
+* });
+*
+* // Override: consumer fully owns the response
+* app.get("/search", idQuery("cursor", usr, {
+*   onError: (failure, req, res) => res.status(failure.status).json({ error: failure.reason }),
+* }), handler);
+* ```
+*/
+declare function idQuery<ParamKey extends string, Brand extends string>(queryName: ParamKey, codec: IdCodec<Brand>, options?: IdParamOptions): (req: Request, res: Response<unknown, Record<ParamKey, Id<Brand>>>, next: NextFunction) => void;
 //#endregion
-export { IdParamError, type IdParamFailure, IdParamOptions, idParam };
+export { IdParamError, type IdParamFailure, IdParamOptions, idParam, idQuery };
 //# sourceMappingURL=express.d.mts.map

package/dist/express.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"express.d.mts","names":[],"sources":["../src/adapters/express.ts"],"mappings":";;;;;;AAUA;;;cAAa,YAAA,SAAqB,KAAA;EAAA,SACvB,MAAA;EAAA,SACA,MAAA;EAET,WAAA,CAAY,MAAA,kCAAwC,MAAA;AAAA;;KAS1C,cAAA;EAT0C;AAAA;AAStD;;EAKE,OAAA,IAAW,OAAA,EAAS,cAAA,EAAgB,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,QAAA,EAAU,IAAA,EAAM,YAAA;;;;;EAKvE,MAAA;IAAW,cAAA;IAAyB,SAAA;EAAA;AAAA;;;;;;;;;;;AAAA;AAmDtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI6E;iBAJ7D,OAAA,gDACd,SAAA,EAAW,QAAA,EACX,KAAA,EAAO,OAAA,CAAQ,KAAA,GACf,OAAA,GAAU,cAAA,IACR,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,QAAA,UAAkB,MAAA,CAAO,QAAA,EAAU,EAAA,CAAG,KAAA,KAAU,IAAA,EAAM,YAAA"}
+{"version":3,"file":"express.d.mts","names":[],"sources":["../src/adapters/express.ts"],"mappings":";;;;;;AAUA;;;cAAa,YAAA,SAAqB,KAAA;EAAA,SACvB,MAAA;EAAA,SACA,MAAA;EAET,WAAA,CAAY,MAAA,kCAAwC,MAAA;AAAA;;KAS1C,cAAA;EAT0C;AAAA;AAStD;;EAKE,OAAA,IAAW,OAAA,EAAS,cAAA,EAAgB,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,QAAA,EAAU,IAAA,EAAM,YAAA;;;;;EAKvE,MAAA;IAAW,cAAA;IAAyB,SAAA;EAAA;AAAA;;;;;;;;;;;AAAA;AAmDtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI6E;iBAJ7D,OAAA,gDACd,SAAA,EAAW,QAAA,EACX,KAAA,EAAO,OAAA,CAAQ,KAAA,GACf,OAAA,GAAU,cAAA,IACR,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,QAAA,UAAkB,MAAA,CAAO,QAAA,EAAU,EAAA,CAAG,KAAA,KAAU,IAAA,EAAM,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA;;;;;;;;;iBAJ7D,OAAA,gDACd,SAAA,EAAW,QAAA,EACX,KAAA,EAAO,OAAA,CAAQ,KAAA,GACf,OAAA,GAAU,cAAA,IACR,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,QAAA,UAAkB,MAAA,CAAO,QAAA,EAAU,EAAA,CAAG,KAAA,KAAU,IAAA,EAAM,YAAA"}