@smonn/ids 0.11.0 → 0.12.0

package/README.md

@@ -69,8 +69,9 @@ Try them all live in the [playground](https://ids.smonn.se/playground/).
 Framework and ORM adapters ship as optional subpath exports (each requires its
 own peer dependency):
 
-- **HTTP route params:** [Hono](https://ids.smonn.se/adapters/hono/), [Express](https://ids.smonn.se/adapters/express/), [Fastify](https://ids.smonn.se/adapters/fastify/) — `idParam` middleware
-- **ORM columns:** [Drizzle](https://ids.smonn.se/adapters/drizzle/), [Kysely](https://ids.smonn.se/adapters/kysely/), [Prisma](https://ids.smonn.se/adapters/prisma/)
+- **HTTP route params:** [Hono](https://ids.smonn.se/adapters/hono/), [Express](https://ids.smonn.se/adapters/express/), [Fastify](https://ids.smonn.se/adapters/fastify/) — `idParam` middleware; [NestJS](https://ids.smonn.se/adapters/nestjs/) — `ParseIdPipe`
+- **ORM columns:** [Drizzle](https://ids.smonn.se/adapters/drizzle/) — `idColumn`, [Kysely](https://ids.smonn.se/adapters/kysely/) — `idColumn`, [MikroORM](https://ids.smonn.se/adapters/mikro-orm/) — `idType`, [Prisma](https://ids.smonn.se/adapters/prisma/) — `idField`, [TypeORM](https://ids.smonn.se/adapters/typeorm/) — `idTransformer`
+- **GraphQL:** [GraphQL](https://ids.smonn.se/adapters/graphql/) — `idScalar` custom scalar
 - **CLI:** brand-agnostic `inspect` / `generate` / `keygen` — `npx @smonn/ids --help` ([docs](https://ids.smonn.se/cli/))
 
 Every codec also implements [Standard Schema v1](https://standardschema.dev/), so

package/dist/graphql.d.mts

@@ -0,0 +1,31 @@
+import { t as Id } from "./types-g7CiQDyE.mjs";
+import { t as IdCodec } from "./adapter-types-CdYJM6Sf.mjs";
+import { GraphQLScalarType } from "graphql";
+
+//#region src/adapters/graphql.d.ts
+/**
+* Builds a `GraphQLScalarType` for the given codec and brand.
+*
+* - `serialize` — identity pass-through; an `Id<Brand>` is already the canonical wire string.
+* - `parseValue` — validates variables via `codec.safeParse`; throws `GraphQLError` on failure.
+* - `parseLiteral` — validates inline `Kind.STRING` literals; throws `GraphQLError` for any
+*   other AST kind or on a failed `safeParse`.
+*
+* `graphql` must be installed as a peer dependency.
+*
+* @example
+* ```ts
+* import { idScalar } from "@smonn/ids/graphql";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* const UserIdScalar = idScalar(usr, { name: "UserId", description: "A branded user ID." });
+* ```
+*/
+declare function idScalar<Brand extends string>(codec: IdCodec<Brand>, config: {
+  name: string;
+  description?: string;
+}): GraphQLScalarType<Id<Brand>, string>;
+//#endregion
+export { idScalar };
+//# sourceMappingURL=graphql.d.mts.map

package/dist/graphql.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.mts","names":[],"sources":["../src/adapters/graphql.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;;iBAAgB,QAAA,uBACd,KAAA,EAAO,OAAA,CAAQ,KAAA,GACf,MAAA;EAAU,IAAA;EAAc,WAAA;AAAA,IACvB,iBAAA,CAAkB,EAAA,CAAG,KAAA"}

package/dist/graphql.mjs

@@ -0,0 +1,42 @@
+import { GraphQLError, GraphQLScalarType, Kind } from "graphql";
+//#region src/adapters/graphql.ts
+/**
+* Builds a `GraphQLScalarType` for the given codec and brand.
+*
+* - `serialize` — identity pass-through; an `Id<Brand>` is already the canonical wire string.
+* - `parseValue` — validates variables via `codec.safeParse`; throws `GraphQLError` on failure.
+* - `parseLiteral` — validates inline `Kind.STRING` literals; throws `GraphQLError` for any
+*   other AST kind or on a failed `safeParse`.
+*
+* `graphql` must be installed as a peer dependency.
+*
+* @example
+* ```ts
+* import { idScalar } from "@smonn/ids/graphql";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+* const UserIdScalar = idScalar(usr, { name: "UserId", description: "A branded user ID." });
+* ```
+*/
+function idScalar(codec, config) {
+	const parse = (value) => {
+		const result = codec.safeParse(value);
+		if (!result.ok) throw new GraphQLError(`invalid ${config.name}: ${result.error}`);
+		return result.id;
+	};
+	return new GraphQLScalarType({
+		name: config.name,
+		description: config.description,
+		serialize: (value) => value,
+		parseValue: parse,
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.STRING) throw new GraphQLError(`${config.name} must be a string literal, got ${ast.kind}`);
+			return parse(ast.value);
+		}
+	});
+}
+//#endregion
+export { idScalar };
+
+//# sourceMappingURL=graphql.mjs.map

package/dist/graphql.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.mjs","names":[],"sources":["../src/adapters/graphql.ts"],"sourcesContent":["import { GraphQLError, GraphQLScalarType, Kind } from \"graphql\";\nimport type { ValueNode } from \"graphql\";\nimport type { IdCodec } from \"./adapter-types.js\";\nimport type { Id } from \"../types.js\";\n\n/**\n * Builds a `GraphQLScalarType` for the given codec and brand.\n *\n * - `serialize` — identity pass-through; an `Id<Brand>` is already the canonical wire string.\n * - `parseValue` — validates variables via `codec.safeParse`; throws `GraphQLError` on failure.\n * - `parseLiteral` — validates inline `Kind.STRING` literals; throws `GraphQLError` for any\n *   other AST kind or on a failed `safeParse`.\n *\n * `graphql` must be installed as a peer dependency.\n *\n * @example\n * ```ts\n * import { idScalar } from \"@smonn/ids/graphql\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n * const UserIdScalar = idScalar(usr, { name: \"UserId\", description: \"A branded user ID.\" });\n * ```\n */\nexport function idScalar<Brand extends string>(\n  codec: IdCodec<Brand>,\n  config: { name: string; description?: string },\n): GraphQLScalarType<Id<Brand>, string> {\n  const parse = (value: unknown): Id<Brand> => {\n    const result = codec.safeParse(value);\n    if (!result.ok) {\n      throw new GraphQLError(`invalid ${config.name}: ${result.error}`);\n    }\n    return result.id;\n  };\n  return new GraphQLScalarType<Id<Brand>, string>({\n    name: config.name,\n    description: config.description,\n    serialize: (value) => value as string,\n    parseValue: parse,\n    parseLiteral: (ast: ValueNode) => {\n      if (ast.kind !== Kind.STRING) {\n        throw new GraphQLError(`${config.name} must be a string literal, got ${ast.kind}`);\n      }\n      return parse(ast.value);\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,SACd,OACA,QACsC;CACtC,MAAM,SAAS,UAA8B;EAC3C,MAAM,SAAS,MAAM,UAAU,KAAK;EACpC,IAAI,CAAC,OAAO,IACV,MAAM,IAAI,aAAa,WAAW,OAAO,KAAK,IAAI,OAAO,OAAO;EAElE,OAAO,OAAO;CAChB;CACA,OAAO,IAAI,kBAAqC;EAC9C,MAAM,OAAO;EACb,aAAa,OAAO;EACpB,YAAY,UAAU;EACtB,YAAY;EACZ,eAAe,QAAmB;GAChC,IAAI,IAAI,SAAS,KAAK,QACpB,MAAM,IAAI,aAAa,GAAG,OAAO,KAAK,iCAAiC,IAAI,MAAM;GAEnF,OAAO,MAAM,IAAI,KAAK;EACxB;CACF,CAAC;AACH"}

package/dist/mikro-orm.d.mts

@@ -0,0 +1,37 @@
+import { n as IdsErrorCode, r as isIdsError, t as IdsError } from "./error-JIPylU_E.mjs";
+import { t as Id } from "./types-g7CiQDyE.mjs";
+import { n as IdColumnCodec } from "./adapter-types-CdYJM6Sf.mjs";
+import { Type } from "@mikro-orm/core";
+
+//#region src/adapters/mikro-orm.d.ts
+/**
+* Factory that returns a MikroORM `Type` subclass bound to a codec.
+*
+* **Write path** (`convertToDatabaseValue`): passes the `Id<Brand>` through
+* unchanged — it is already the canonical string form.
+*
+* **Read path** (`convertToJSValue`): normalises the raw DB value via
+* `codec.safeParse()`. Throws `IdsError("invalid_id")` if the stored value
+* does not parse as a valid `Id<Brand>`.
+*
+* **Column type** (`getColumnType`): returns `"text"`.
+*
+* @example
+* ```ts
+* import { PrimaryKey } from "@mikro-orm/core";
+* import { idType } from "@smonn/ids/mikro-orm";
+* import { createTimestampId } from "@smonn/ids";
+* import type { Id } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+*
+* class User {
+*   @PrimaryKey({ type: idType(usr) })
+*   id!: Id<"usr">;
+* }
+* ```
+*/
+declare function idType<Brand extends string>(codec: IdColumnCodec<Brand>): new () => Type<Id<Brand>, string>;
+//#endregion
+export { type IdColumnCodec, IdsError, type IdsErrorCode, idType, isIdsError };
+//# sourceMappingURL=mikro-orm.d.mts.map

package/dist/mikro-orm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm.d.mts","names":[],"sources":["../src/adapters/mikro-orm.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuCqB;;;;;;;;;;iBAFL,MAAA,uBACd,KAAA,EAAO,aAAA,CAAc,KAAA,cACV,IAAA,CAAK,EAAA,CAAG,KAAA"}

package/dist/mikro-orm.mjs

@@ -0,0 +1,48 @@
+import { n as isIdsError, t as IdsError } from "./error-Cp5qYZcv.mjs";
+import { t as readIdColumn } from "./adapter-types-7wWdELSh.mjs";
+import { Type } from "@mikro-orm/core";
+//#region src/adapters/mikro-orm.ts
+/**
+* Factory that returns a MikroORM `Type` subclass bound to a codec.
+*
+* **Write path** (`convertToDatabaseValue`): passes the `Id<Brand>` through
+* unchanged — it is already the canonical string form.
+*
+* **Read path** (`convertToJSValue`): normalises the raw DB value via
+* `codec.safeParse()`. Throws `IdsError("invalid_id")` if the stored value
+* does not parse as a valid `Id<Brand>`.
+*
+* **Column type** (`getColumnType`): returns `"text"`.
+*
+* @example
+* ```ts
+* import { PrimaryKey } from "@mikro-orm/core";
+* import { idType } from "@smonn/ids/mikro-orm";
+* import { createTimestampId } from "@smonn/ids";
+* import type { Id } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+*
+* class User {
+*   @PrimaryKey({ type: idType(usr) })
+*   id!: Id<"usr">;
+* }
+* ```
+*/
+function idType(codec) {
+	return class extends Type {
+		convertToDatabaseValue(value) {
+			return value;
+		}
+		convertToJSValue(value) {
+			return readIdColumn(codec, value);
+		}
+		getColumnType() {
+			return "text";
+		}
+	};
+}
+//#endregion
+export { IdsError, idType, isIdsError };
+
+//# sourceMappingURL=mikro-orm.mjs.map

package/dist/mikro-orm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm.mjs","names":[],"sources":["../src/adapters/mikro-orm.ts"],"sourcesContent":["import { Type } from \"@mikro-orm/core\";\nimport { IdsError, isIdsError, type IdsErrorCode } from \"../error.js\";\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 };\n\nexport type { IdColumnCodec };\n\n/**\n * Factory that returns a MikroORM `Type` subclass bound to a codec.\n *\n * **Write path** (`convertToDatabaseValue`): passes the `Id<Brand>` through\n * unchanged — it is already the canonical string form.\n *\n * **Read path** (`convertToJSValue`): normalises the raw DB value via\n * `codec.safeParse()`. Throws `IdsError(\"invalid_id\")` if the stored value\n * does not parse as a valid `Id<Brand>`.\n *\n * **Column type** (`getColumnType`): returns `\"text\"`.\n *\n * @example\n * ```ts\n * import { PrimaryKey } from \"@mikro-orm/core\";\n * import { idType } from \"@smonn/ids/mikro-orm\";\n * import { createTimestampId } from \"@smonn/ids\";\n * import type { Id } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n *\n * class User {\n *   @PrimaryKey({ type: idType(usr) })\n *   id!: Id<\"usr\">;\n * }\n * ```\n */\nexport function idType<Brand extends string>(\n  codec: IdColumnCodec<Brand>,\n): new () => Type<Id<Brand>, string> {\n  return class extends Type<Id<Brand>, string> {\n    override convertToDatabaseValue(value: Id<Brand>): string {\n      return value;\n    }\n    override convertToJSValue(value: string): Id<Brand> {\n      return readIdColumn(codec, value);\n    }\n    override getColumnType(): string {\n      return \"text\";\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,OACd,OACmC;CACnC,OAAO,cAAc,KAAwB;EAC3C,uBAAgC,OAA0B;GACxD,OAAO;EACT;EACA,iBAA0B,OAA0B;GAClD,OAAO,aAAa,OAAO,KAAK;EAClC;EACA,gBAAiC;GAC/B,OAAO;EACT;CACF;AACF"}

package/dist/nestjs.d.mts

@@ -0,0 +1,70 @@
+import { t as Id } from "./types-g7CiQDyE.mjs";
+import { r as IdParamFailure, t as IdCodec } from "./adapter-types-CdYJM6Sf.mjs";
+import { ArgumentMetadata, PipeTransform } from "@nestjs/common";
+
+//#region src/adapters/nestjs.d.ts
+/**
+* Options for `ParseIdPipe`. All fields are optional.
+*
+* **`onError` constraint:** NestJS `transform()` receives only `value` and `ArgumentMetadata`
+* — there is no HTTP context object. The `onError` hook must throw (or re-throw); it cannot
+* write a response inline the way Hono/Express hooks can.
+*/
+type IdParamOptions = {
+  /**
+  * Called instead of throwing when provided. The hook **must** throw or re-throw — it cannot
+  * return a response because `PipeTransform.transform` has no HTTP context.
+  */
+  onError?: (failure: IdParamFailure) => never;
+  /**
+  * Remap the default HTTP status for a failure reason without a full handler.
+  * e.g. `{ brand_mismatch: 400 }` treats both failure kinds as 400.
+  */
+  status?: {
+    brand_mismatch?: number;
+    malformed?: number;
+  };
+};
+/**
+* NestJS pipe that validates an untrusted route param against a codec via `safeParse`.
+*
+* Marked `@Injectable()` via `Injectable()(ParseIdPipe)` at module load time, making it
+* available for NestJS DI.
+*
+* **Default (no options):** throws `NotFoundException` (404) for brand mismatches and
+* `BadRequestException` (400) for malformed IDs.
+*
+* **`options.status`:** remaps the default HTTP status for a reason; when the resolved status
+* differs from the default, the pipe throws `HttpException(reason, status)`.
+*
+* **`options.onError`:** escape hatch for custom error handling. The hook must throw — it
+* cannot return a response because `PipeTransform.transform` has no HTTP context.
+*
+* - **Brand mismatch (`invalid_prefix`) → `reason: "brand_mismatch"`, default 404**
+* - **Malformed or missing ID → `reason: "malformed"`, default 400**
+*
+* @example
+* ```ts
+* import { ParseIdPipe } from "@smonn/ids/nestjs";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+*
+* @Controller("users")
+* class UsersController {
+*   @Get(":id")
+*   findOne(@Param("id", new ParseIdPipe(usr)) id: Id<"usr">) {
+*     return { id }; // Id<"usr">, canonical
+*   }
+* }
+* ```
+*/
+declare class ParseIdPipe<Brand extends string> implements PipeTransform<unknown, Id<Brand>> {
+  private readonly codec;
+  private readonly options;
+  constructor(codec: IdCodec<Brand>, options?: IdParamOptions);
+  transform(value: unknown, _metadata: ArgumentMetadata): Id<Brand>;
+}
+//#endregion
+export { type IdParamFailure, IdParamOptions, ParseIdPipe };
+//# sourceMappingURL=nestjs.d.mts.map

package/dist/nestjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.d.mts","names":[],"sources":["../src/adapters/nestjs.ts"],"mappings":";;;;;;AAcA;;;;;;KAAY,cAAA;;;;;EAKV,OAAA,IAAW,OAAA,EAAS,cAAA;EA0CtB;;;;EArCE,MAAA;IAAW,cAAA;IAAyB,SAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;AA8CuB;;;;;;;;;;cAThD,WAAA,kCAA6C,aAAA,UAAuB,EAAA,CAAG,KAAA;EAAA,iBACjE,KAAA;EAAA,iBACA,OAAA;EAEjB,WAAA,CAAY,KAAA,EAAO,OAAA,CAAQ,KAAA,GAAQ,OAAA,GAAU,cAAA;EAK7C,SAAA,CAAU,KAAA,WAAgB,SAAA,EAAW,gBAAA,GAAmB,EAAA,CAAG,KAAA;AAAA"}

package/dist/nestjs.mjs

@@ -0,0 +1,61 @@
+import { n as resolveIdParamFailure } from "./adapter-types-7wWdELSh.mjs";
+import { BadRequestException, HttpException, Injectable, NotFoundException } from "@nestjs/common";
+//#region src/adapters/nestjs.ts
+/**
+* NestJS pipe that validates an untrusted route param against a codec via `safeParse`.
+*
+* Marked `@Injectable()` via `Injectable()(ParseIdPipe)` at module load time, making it
+* available for NestJS DI.
+*
+* **Default (no options):** throws `NotFoundException` (404) for brand mismatches and
+* `BadRequestException` (400) for malformed IDs.
+*
+* **`options.status`:** remaps the default HTTP status for a reason; when the resolved status
+* differs from the default, the pipe throws `HttpException(reason, status)`.
+*
+* **`options.onError`:** escape hatch for custom error handling. The hook must throw — it
+* cannot return a response because `PipeTransform.transform` has no HTTP context.
+*
+* - **Brand mismatch (`invalid_prefix`) → `reason: "brand_mismatch"`, default 404**
+* - **Malformed or missing ID → `reason: "malformed"`, default 400**
+*
+* @example
+* ```ts
+* import { ParseIdPipe } from "@smonn/ids/nestjs";
+* import { createTimestampId } from "@smonn/ids";
+*
+* const usr = createTimestampId("usr");
+*
+* @Controller("users")
+* class UsersController {
+*   @Get(":id")
+*   findOne(@Param("id", new ParseIdPipe(usr)) id: Id<"usr">) {
+*     return { id }; // Id<"usr">, canonical
+*   }
+* }
+* ```
+*/
+var ParseIdPipe = class {
+	codec;
+	options;
+	constructor(codec, options) {
+		this.codec = codec;
+		this.options = options;
+	}
+	transform(value, _metadata) {
+		const result = this.codec.safeParse(value);
+		if (!result.ok) {
+			const failure = resolveIdParamFailure(result.error, this.options);
+			if (this.options?.onError) this.options.onError(failure);
+			if (failure.reason === "brand_mismatch" && failure.status === 404) throw new NotFoundException();
+			if (failure.reason === "malformed" && failure.status === 400) throw new BadRequestException();
+			throw new HttpException(failure.reason, failure.status);
+		}
+		return result.id;
+	}
+};
+Injectable()(ParseIdPipe);
+//#endregion
+export { ParseIdPipe };
+
+//# sourceMappingURL=nestjs.mjs.map

package/dist/nestjs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.mjs","names":[],"sources":["../src/adapters/nestjs.ts"],"sourcesContent":["import { BadRequestException, HttpException, Injectable, NotFoundException } from \"@nestjs/common\";\nimport type { ArgumentMetadata, PipeTransform } from \"@nestjs/common\";\nimport { type IdCodec, type IdParamFailure, resolveIdParamFailure } from \"./adapter-types.js\";\nimport type { Id } from \"../types.js\";\n\nexport type { IdParamFailure };\n\n/**\n * Options for `ParseIdPipe`. All fields are optional.\n *\n * **`onError` constraint:** NestJS `transform()` receives only `value` and `ArgumentMetadata`\n * — there is no HTTP context object. The `onError` hook must throw (or re-throw); it cannot\n * write a response inline the way Hono/Express hooks can.\n */\nexport type IdParamOptions = {\n  /**\n   * Called instead of throwing when provided. The hook **must** throw or re-throw — it cannot\n   * return a response because `PipeTransform.transform` has no HTTP context.\n   */\n  onError?: (failure: IdParamFailure) => never;\n  /**\n   * Remap the default HTTP status for a failure reason without a full handler.\n   * e.g. `{ brand_mismatch: 400 }` treats both failure kinds as 400.\n   */\n  status?: { brand_mismatch?: number; malformed?: number };\n};\n\n/**\n * NestJS pipe that validates an untrusted route param against a codec via `safeParse`.\n *\n * Marked `@Injectable()` via `Injectable()(ParseIdPipe)` at module load time, making it\n * available for NestJS DI.\n *\n * **Default (no options):** throws `NotFoundException` (404) for brand mismatches and\n * `BadRequestException` (400) for malformed IDs.\n *\n * **`options.status`:** remaps the default HTTP status for a reason; when the resolved status\n * differs from the default, the pipe throws `HttpException(reason, status)`.\n *\n * **`options.onError`:** escape hatch for custom error handling. The hook must throw — it\n * cannot return a response because `PipeTransform.transform` has no HTTP context.\n *\n * - **Brand mismatch (`invalid_prefix`) → `reason: \"brand_mismatch\"`, default 404**\n * - **Malformed or missing ID → `reason: \"malformed\"`, default 400**\n *\n * @example\n * ```ts\n * import { ParseIdPipe } from \"@smonn/ids/nestjs\";\n * import { createTimestampId } from \"@smonn/ids\";\n *\n * const usr = createTimestampId(\"usr\");\n *\n * @Controller(\"users\")\n * class UsersController {\n *   @Get(\":id\")\n *   findOne(@Param(\"id\", new ParseIdPipe(usr)) id: Id<\"usr\">) {\n *     return { id }; // Id<\"usr\">, canonical\n *   }\n * }\n * ```\n */\nexport class ParseIdPipe<Brand extends string> implements PipeTransform<unknown, Id<Brand>> {\n  private readonly codec: IdCodec<Brand>;\n  private readonly options: IdParamOptions | undefined;\n\n  constructor(codec: IdCodec<Brand>, options?: IdParamOptions) {\n    this.codec = codec;\n    this.options = options;\n  }\n\n  transform(value: unknown, _metadata: ArgumentMetadata): Id<Brand> {\n    const result = this.codec.safeParse(value);\n    if (!result.ok) {\n      const failure = resolveIdParamFailure(result.error, this.options);\n      if (this.options?.onError) {\n        this.options.onError(failure);\n      }\n      if (failure.reason === \"brand_mismatch\" && failure.status === 404) {\n        throw new NotFoundException();\n      }\n      if (failure.reason === \"malformed\" && failure.status === 400) {\n        throw new BadRequestException();\n      }\n      throw new HttpException(failure.reason, failure.status);\n    }\n    return result.id;\n  }\n}\n\n// Apply @Injectable() metadata so ParseIdPipe participates in NestJS DI when provided as a class.\n// Using a call instead of the @Injectable() decorator syntax to remain compatible with\n// TypeScript projects that do not enable experimentalDecorators.\nInjectable()(ParseIdPipe as unknown as new (...args: unknown[]) => unknown);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,IAAa,cAAb,MAA4F;CAC1F;CACA;CAEA,YAAY,OAAuB,SAA0B;EAC3D,KAAK,QAAQ;EACb,KAAK,UAAU;CACjB;CAEA,UAAU,OAAgB,WAAwC;EAChE,MAAM,SAAS,KAAK,MAAM,UAAU,KAAK;EACzC,IAAI,CAAC,OAAO,IAAI;GACd,MAAM,UAAU,sBAAsB,OAAO,OAAO,KAAK,OAAO;GAChE,IAAI,KAAK,SAAS,SAChB,KAAK,QAAQ,QAAQ,OAAO;GAE9B,IAAI,QAAQ,WAAW,oBAAoB,QAAQ,WAAW,KAC5D,MAAM,IAAI,kBAAkB;GAE9B,IAAI,QAAQ,WAAW,eAAe,QAAQ,WAAW,KACvD,MAAM,IAAI,oBAAoB;GAEhC,MAAM,IAAI,cAAc,QAAQ,QAAQ,QAAQ,MAAM;EACxD;EACA,OAAO,OAAO;CAChB;AACF;AAKA,WAAW,CAAC,CAAC,WAA6D"}

package/dist/typeorm.d.mts

@@ -0,0 +1,41 @@
+import { n as IdsErrorCode, r as isIdsError, t as IdsError } from "./error-JIPylU_E.mjs";
+import { n as IdColumnCodec } from "./adapter-types-CdYJM6Sf.mjs";
+import { ValueTransformer } from "typeorm";
+
+//#region src/adapters/typeorm.d.ts
+/**
+* TypeORM column transformer for `Id<Brand>`.
+*
+* Returns a `ValueTransformer` object suitable for use in a TypeORM `@Column`
+* decorator's `transformer` option.
+*
+* **Write path (`to`):** passes the `Id<Brand>` directly to the database — it is
+* already the canonical string form.
+*
+* **Read path (`from`):** normalises the raw database value via `codec.safeParse()`.
+* Throws `IdsError` with code `"invalid_id"` if the value does not parse as a valid
+* `Id<Brand>`.
+*
+* **TypeORM branding caveat:** TypeORM cannot brand a generated entity field type at
+* the schema level. Annotate the entity field explicitly: `id!: Id<"usr">`.
+*
+* @example
+* ```ts
+* import { idTransformer } from "@smonn/ids/typeorm";
+* import { createTimestampId } from "@smonn/ids";
+* import type { Id } from "@smonn/ids";
+* import { Column, Entity } from "typeorm";
+*
+* const usr = createTimestampId("usr");
+*
+* @Entity()
+* class User {
+*   @Column({ type: "text", transformer: idTransformer(usr) })
+*   id!: Id<"usr">;
+* }
+* ```
+*/
+declare function idTransformer<Brand extends string>(codec: IdColumnCodec<Brand>): ValueTransformer;
+//#endregion
+export { type IdColumnCodec, IdsError, type IdsErrorCode, idTransformer, isIdsError };
+//# sourceMappingURL=typeorm.d.mts.map

package/dist/typeorm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.d.mts","names":[],"sources":["../src/adapters/typeorm.ts"],"mappings":";;;;;;;;;;;;;;;;;;AA0CkF;;;;;;;;;;;;;;;;;;;iBAAlE,aAAA,uBAAoC,KAAA,EAAO,aAAA,CAAc,KAAA,IAAS,gBAAA"}

package/dist/typeorm.mjs

@@ -0,0 +1,49 @@
+import { n as isIdsError, t as IdsError } from "./error-Cp5qYZcv.mjs";
+import { t as readIdColumn } from "./adapter-types-7wWdELSh.mjs";
+//#region src/adapters/typeorm.ts
+/**
+* TypeORM column transformer for `Id<Brand>`.
+*
+* Returns a `ValueTransformer` object suitable for use in a TypeORM `@Column`
+* decorator's `transformer` option.
+*
+* **Write path (`to`):** passes the `Id<Brand>` directly to the database — it is
+* already the canonical string form.
+*
+* **Read path (`from`):** normalises the raw database value via `codec.safeParse()`.
+* Throws `IdsError` with code `"invalid_id"` if the value does not parse as a valid
+* `Id<Brand>`.
+*
+* **TypeORM branding caveat:** TypeORM cannot brand a generated entity field type at
+* the schema level. Annotate the entity field explicitly: `id!: Id<"usr">`.
+*
+* @example
+* ```ts
+* import { idTransformer } from "@smonn/ids/typeorm";
+* import { createTimestampId } from "@smonn/ids";
+* import type { Id } from "@smonn/ids";
+* import { Column, Entity } from "typeorm";
+*
+* const usr = createTimestampId("usr");
+*
+* @Entity()
+* class User {
+*   @Column({ type: "text", transformer: idTransformer(usr) })
+*   id!: Id<"usr">;
+* }
+* ```
+*/
+function idTransformer(codec) {
+	return {
+		to(value) {
+			return value;
+		},
+		from(value) {
+			return readIdColumn(codec, value);
+		}
+	};
+}
+//#endregion
+export { IdsError, idTransformer, isIdsError };
+
+//# sourceMappingURL=typeorm.mjs.map

package/dist/typeorm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.mjs","names":[],"sources":["../src/adapters/typeorm.ts"],"sourcesContent":["import type { ValueTransformer } from \"typeorm\";\nimport { IdsError, isIdsError, type IdsErrorCode } from \"../error.js\";\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 };\n\nexport type { IdColumnCodec };\n\n/**\n * TypeORM column transformer for `Id<Brand>`.\n *\n * Returns a `ValueTransformer` object suitable for use in a TypeORM `@Column`\n * decorator's `transformer` option.\n *\n * **Write path (`to`):** passes the `Id<Brand>` directly to the database — it is\n * already the canonical string form.\n *\n * **Read path (`from`):** normalises the raw database value via `codec.safeParse()`.\n * Throws `IdsError` with code `\"invalid_id\"` if the value does not parse as a valid\n * `Id<Brand>`.\n *\n * **TypeORM branding caveat:** TypeORM cannot brand a generated entity field type at\n * the schema level. Annotate the entity field explicitly: `id!: Id<\"usr\">`.\n *\n * @example\n * ```ts\n * import { idTransformer } from \"@smonn/ids/typeorm\";\n * import { createTimestampId } from \"@smonn/ids\";\n * import type { Id } from \"@smonn/ids\";\n * import { Column, Entity } from \"typeorm\";\n *\n * const usr = createTimestampId(\"usr\");\n *\n * @Entity()\n * class User {\n *   @Column({ type: \"text\", transformer: idTransformer(usr) })\n *   id!: Id<\"usr\">;\n * }\n * ```\n */\nexport function idTransformer<Brand extends string>(codec: IdColumnCodec<Brand>): ValueTransformer {\n  return {\n    to(value: Id<Brand>): string {\n      return value;\n    },\n    from(value: unknown): Id<Brand> {\n      return readIdColumn(codec, value);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,cAAoC,OAA+C;CACjG,OAAO;EACL,GAAG,OAA0B;GAC3B,OAAO;EACT;EACA,KAAK,OAA2B;GAC9B,OAAO,aAAa,OAAO,KAAK;EAClC;CACF;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smonn/ids",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "license": "MIT",
   "author": "Simon Ingeson (https://github.com/smonn)",
   "repository": {
@@ -24,13 +24,19 @@
     "./drizzle": "./dist/drizzle.mjs",
     "./hono": "./dist/hono.mjs",
     "./kysely": "./dist/kysely.mjs",
+    "./mikro-orm": "./dist/mikro-orm.mjs",
     "./prisma": "./dist/prisma.mjs",
     "./express": "./dist/express.mjs",
     "./fastify": "./dist/fastify.mjs",
+    "./typeorm": "./dist/typeorm.mjs",
+    "./graphql": "./dist/graphql.mjs",
+    "./nestjs": "./dist/nestjs.mjs",
     "./package.json": "./package.json"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.0",
+    "@mikro-orm/core": "^7.1.4",
+    "@nestjs/common": "^11.1.27",
     "@prisma/client": ">=5.0.0",
     "@types/express": "^5.0.6",
     "@types/node": "24.13.2",
@@ -39,25 +45,36 @@
     "drizzle-orm": "^0.45.2",
     "express": "^5.2.1",
     "fastify": "^5.8.5",
+    "graphql": "^17.0.1",
     "hono": "^4.12.26",
     "knip": "6.18.0",
     "kysely": "^0.29.2",
     "mitata": "1.0.34",
     "oxfmt": "0.55.0",
     "oxlint": "1.70.0",
+    "reflect-metadata": "^0.2.2",
     "tsdown": "0.22.3",
+    "tslib": "^2.8.1",
+    "typeorm": "^1.0.0",
     "typescript": "6.0.3",
     "vitest": "4.1.9"
   },
   "peerDependencies": {
+    "@mikro-orm/core": ">=6.0.0",
+    "@nestjs/common": ">=10.0.0",
     "@prisma/client": ">=5.0.0",
     "drizzle-orm": ">=0.30.0",
     "express": ">=4.0.0",
     "fastify": ">=4.0.0",
+    "graphql": ">=16.0.0",
     "hono": ">=4.0.0",
-    "kysely": ">=0.27.0"
+    "kysely": ">=0.27.0",
+    "typeorm": ">=0.3.0"
   },
   "peerDependenciesMeta": {
+    "@mikro-orm/core": {
+      "optional": true
+    },
     "drizzle-orm": {
       "optional": true
     },
@@ -67,6 +84,9 @@
     "fastify": {
       "optional": true
     },
+    "graphql": {
+      "optional": true
+    },
     "hono": {
       "optional": true
     },
@@ -75,6 +95,12 @@
     },
     "@prisma/client": {
       "optional": true
+    },
+    "typeorm": {
+      "optional": true
+    },
+    "@nestjs/common": {
+      "optional": true
     }
   },
   "engines": {