@classytic/arc 2.8.5 → 2.10.3

package/dist/EventTransport-CUw5NNWe.d.mts

@@ -0,0 +1,293 @@
+//#region src/events/EventTransport.d.ts
+/**
+ * Event Transport Interface
+ *
+ * Defines contract for event delivery backends.
+ * Implement for durable transports (Redis, RabbitMQ, Kafka, etc.)
+ *
+ * @example
+ * // Redis Pub/Sub implementation
+ * class RedisEventTransport implements EventTransport {
+ *   async publish(event) {
+ *     await redis.publish(event.type, JSON.stringify(event));
+ *   }
+ *   async subscribe(pattern, handler) {
+ *     redis.psubscribe(pattern);
+ *     redis.on('pmessage', (p, channel, msg) => handler(JSON.parse(msg)));
+ *   }
+ * }
+ */
+/**
+ * Event metadata.
+ *
+ * Split out as a standalone interface so primitives / downstream packages can
+ * mirror it without re-declaring the DomainEvent wrapper. See events.ts in
+ * @classytic/primitives for the sibling shape.
+ */
+interface EventMeta {
+  /** Unique event ID (UUID v4 recommended) */
+  id: string;
+  /** Event timestamp */
+  timestamp: Date;
+  /**
+   * Schema version for this event type. Default: `1`.
+   *
+   * Use when the payload shape evolves so handlers can branch on version
+   * during migration windows (`if (event.meta.schemaVersion === 2) ...`).
+   * Bump ONLY when the payload contract changes in a breaking way.
+   */
+  schemaVersion?: number;
+  /**
+   * Correlation ID — stays stable across an entire causal chain so a single
+   * user action can be traced through every downstream event. Spans service
+   * boundaries. Generated at the edge (HTTP request, CLI invocation) and
+   * inherited by every child event.
+   */
+  correlationId?: string;
+  /**
+   * Causation ID — the `meta.id` of the direct parent event that caused
+   * this one. Forms a linked-list of cause-and-effect within a correlation.
+   *
+   * Distinct from correlationId: correlation groups, causation chains.
+   * Use {@link createChildEvent} to populate this automatically.
+   */
+  causationId?: string;
+  /**
+   * Partition key hint for ordered transports (Kafka, Kinesis, Redis Streams
+   * consumer groups). Events with the same partitionKey are guaranteed to be
+   * delivered in publish order by transports that honour it.
+   *
+   * Defaults to `resourceId` if unset. Transports that don't support ordering
+   * (in-memory, simple pub/sub) ignore this field.
+   */
+  partitionKey?: string;
+  /** Source resource (e.g. 'order', 'transaction') */
+  resource?: string;
+  /** Resource identifier */
+  resourceId?: string;
+  /** User who triggered the event */
+  userId?: string;
+  /** Organization context */
+  organizationId?: string;
+  /**
+   * Originating service or package (e.g. `'commerce'`, `'billing'`, `'arc-core'`).
+   *
+   * In a multi-service deployment, consumers route / log / alert by `source`
+   * without parsing `type` prefixes. Arc itself never populates this — hosts
+   * set it once per emitter (`app.events.publish('order.placed', p, { source: 'commerce' })`).
+   * Inherited by {@link createChildEvent} so downstream events carry the same
+   * source unless overridden.
+   */
+  source?: string;
+  /**
+   * Idempotency key — stable hint that this event represents a specific
+   * operation exactly once. Consumers dedupe with `if (processed.has(meta.idempotencyKey)) return`.
+   *
+   * Survives every transport (Memory / Pub-Sub / Streams / Kafka) because it's
+   * part of the event, not a transport-side option. Distinct from `meta.id`
+   * (which is fresh per emit — a retry would produce a new id).
+   *
+   * Typical sources: HTTP `Idempotency-Key` header, outbox `dedupeKey`, or
+   * `{aggregate.type}:{aggregate.id}:{action}`. Inherited by child events.
+   */
+  idempotencyKey?: string;
+  /**
+   * DDD aggregate marker — the aggregate that owns this event's invariant.
+   *
+   * Use when routing events by aggregate, doing event-sourcing replay, or
+   * enforcing consistency boundaries. Distinct from `resource` / `resourceId`
+   * (HTTP-origin entity) because an event emitted *by* one REST resource can
+   * *belong to* a different aggregate (e.g. `POST /orders/:id/ship` emits
+   * `shipment.dispatched` owned by a shipment aggregate).
+   *
+   * Downstream packages narrow `aggregate.type` to their own string union via
+   * interface extension:
+   *
+   * ```ts
+   * type CartAggregateType = 'cart' | 'cart-item';
+   * interface CartEventMeta extends EventMeta {
+   *   aggregate?: { type: CartAggregateType; id: string };
+   * }
+   * ```
+   *
+   * Not inherited by {@link createChildEvent} — child events typically belong
+   * to a different aggregate than their parent.
+   */
+  aggregate?: {
+    type: string;
+    id: string;
+  };
+}
+interface DomainEvent<T = unknown> {
+  /** Event type (e.g., 'product.created', 'order.shipped') */
+  type: string;
+  /** Event payload */
+  payload: T;
+  /** Event metadata */
+  meta: EventMeta;
+}
+type EventHandler<T = unknown> = (event: DomainEvent<T>) => void | Promise<void>;
+/**
+ * A permanently-failed event routed to a dead-letter sink after retries
+ * have been exhausted. Mirrors the shape a caller would log, alert on, or
+ * replay from once the upstream issue is fixed.
+ */
+interface DeadLetteredEvent<T = unknown> {
+  /** The original event */
+  event: DomainEvent<T>;
+  /** Serialised failure reason (message + optional machine code + stack) */
+  error: {
+    message: string;
+    code?: string;
+    stack?: string;
+  };
+  /** How many delivery attempts were made before giving up */
+  attempts: number;
+  /** First failure timestamp */
+  firstFailedAt: Date;
+  /** Last failure timestamp (immediately before dead-lettering) */
+  lastFailedAt: Date;
+  /** Optional handler / subscriber name that last failed (for debug) */
+  handlerName?: string;
+}
+/**
+ * Minimal logger interface for event transports.
+ * Compatible with `console`, `pino`, `fastify.log`, and any custom logger.
+ *
+ * @example
+ * ```typescript
+ * // Use Fastify's logger
+ * new MemoryEventTransport({ logger: fastify.log });
+ *
+ * // Use a custom logger
+ * new MemoryEventTransport({ logger: { warn: myWarn, error: myError } });
+ *
+ * // Default: console (no logger option needed)
+ * new MemoryEventTransport();
+ * ```
+ */
+interface EventLogger {
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+interface EventTransport {
+  /** Transport name for logging */
+  readonly name: string;
+  /**
+   * Publish an event to the transport
+   */
+  publish(event: DomainEvent): Promise<void>;
+  /**
+   * Publish a batch of events to the transport (optional, v2.8.1+).
+   *
+   * Transports that can efficiently batch (Kafka producer, Redis pipeline,
+   * RabbitMQ publisher confirms, SQS send-message-batch) should implement
+   * this. {@link import('./outbox.js').EventOutbox.relay} auto-detects and
+   * uses it for much higher throughput than per-event publishing.
+   *
+   * **Contract**: the returned `PublishManyResult` must describe the
+   * per-event outcome so the caller can acknowledge successes and fail the
+   * rest. Partial success is allowed — the transport reports it per event.
+   *
+   * If not implemented, `EventOutbox.relay` falls back to calling
+   * {@link publish} once per event.
+   *
+   * @param events - Events to publish (in order)
+   * @returns Per-event outcome map keyed by `event.meta.id`
+   */
+  publishMany?(events: readonly DomainEvent[]): Promise<PublishManyResult>;
+  /**
+   * Subscribe to events matching a pattern
+   * @param pattern - Event type pattern (e.g., 'product.*', '*')
+   * @param handler - Handler function
+   * @returns Unsubscribe function
+   */
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  /**
+   * Route a permanently-failed event to the transport's dead-letter sink
+   * (Kafka DLQ topic, SQS DLQ, Redis Stream `PEL` timeout handler, etc.).
+   *
+   * Called by {@link import('./outbox.js').EventOutbox} after exhausting
+   * retries. Transports that don't have a native DLQ can omit this —
+   * callers treat an absent `deadLetter` as "log and drop".
+   */
+  deadLetter?(dlq: DeadLetteredEvent): Promise<void>;
+  /**
+   * Close transport connections
+   */
+  close?(): Promise<void>;
+}
+/**
+ * Per-event outcome returned by {@link EventTransport.publishMany}.
+ *
+ * The key is `event.meta.id`; the value is `null` for success or an `Error`
+ * for per-event failure. Transports MUST include an entry for every event
+ * in the input batch.
+ */
+type PublishManyResult = ReadonlyMap<string, Error | null>;
+interface MemoryEventTransportOptions {
+  /** Logger for error/warning messages (default: console) */
+  logger?: EventLogger;
+}
+/**
+ * In-memory event transport (default)
+ * Events are delivered synchronously within the process.
+ * Not suitable for multi-instance deployments.
+ */
+declare class MemoryEventTransport implements EventTransport {
+  readonly name = "memory";
+  private handlers;
+  private logger;
+  constructor(options?: MemoryEventTransportOptions);
+  publish(event: DomainEvent): Promise<void>;
+  /**
+   * Reference `publishMany` implementation — delegates to `publish()` in order.
+   *
+   * Production transports (Kafka, Redis pipeline, SQS batch) should override
+   * this with a single batched network call. Memory transport has nothing to
+   * batch, so we just loop — the loop still returns a proper result map so
+   * `EventOutbox.relay` can exercise the batched code path in tests.
+   */
+  publishMany(events: readonly DomainEvent[]): Promise<PublishManyResult>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  close(): Promise<void>;
+}
+/**
+ * Create a domain event with auto-generated metadata.
+ *
+ * `id` and `timestamp` are filled in; everything else is caller-controlled.
+ * Set `schemaVersion` explicitly for any event type you plan to evolve.
+ */
+declare function createEvent<T>(type: string, payload: T, meta?: Partial<EventMeta>): DomainEvent<T>;
+/**
+ * Create a child event that chains causation from a parent event.
+ *
+ * Rules:
+ *  - `causationId` is set to the parent's `id` (direct cause)
+ *  - `correlationId` is inherited from the parent if set, else falls back
+ *    to the parent's `id` (root correlation)
+ *  - `userId` / `organizationId` are inherited when not overridden so the
+ *    whole chain stays scoped to the originating principal/tenant
+ *
+ * Caller-supplied `meta` wins over inherited fields — pass `{ userId: newActor }`
+ * to override when a subsystem acts on behalf of a different principal.
+ *
+ * @example
+ * ```typescript
+ * const orderPlaced = createEvent('order.placed', { orderId: 'o1' }, {
+ *   correlationId: req.id, userId: user.id,
+ * });
+ * await events.publish(orderPlaced);
+ *
+ * // Downstream handler emits a child event:
+ * const reserved = createChildEvent(orderPlaced, 'inventory.reserved', {
+ *   orderId: 'o1', skus: ['sku-1', 'sku-2'],
+ * });
+ * // reserved.meta.causationId   === orderPlaced.meta.id
+ * // reserved.meta.correlationId === orderPlaced.meta.correlationId
+ * // reserved.meta.userId        === user.id   (inherited)
+ * ```
+ */
+declare function createChildEvent<T>(parent: DomainEvent, type: string, payload: T, meta?: Partial<EventMeta>): DomainEvent<T>;
+//#endregion
+export { EventMeta as a, MemoryEventTransportOptions as c, createEvent as d, EventLogger as i, PublishManyResult as l, DomainEvent as n, EventTransport as o, EventHandler as r, MemoryEventTransport as s, DeadLetteredEvent as t, createChildEvent as u };

package/dist/{ResourceRegistry-C6uXlWe3.mjs → ResourceRegistry-BPd6NQDm.mjs}

@@ -1,4 +1,4 @@
-import { t as CRUD_OPERATIONS } from "./constants-Cxde4rpC.mjs";
+import { t as CRUD_OPERATIONS } from "./constants-BhY1OHoH.mjs";
 //#region src/registry/ResourceRegistry.ts
 /**
 * Resource Registry

package/dist/adapters/index.d.mts

@@ -1,3 +1,3 @@
-import { a as RelationMetadata, c as ValidationResult, i as FieldMetadata, o as RepositoryLike, r as DataAdapter, s as SchemaMetadata, t as AdapterFactory } from "../interface-CMRutPfe.mjs";
-import { a as PrismaQueryParserOptions, c as MongooseAdapterOptions, i as PrismaQueryParser, l as createMongooseAdapter, n as PrismaAdapterOptions, o as createPrismaAdapter, r as PrismaQueryOptions, s as MongooseAdapter, t as PrismaAdapter } from "../index-C1meYuDn.mjs";
-export { AdapterFactory, DataAdapter, FieldMetadata, MongooseAdapter, MongooseAdapterOptions, PrismaAdapter, PrismaAdapterOptions, PrismaQueryOptions, PrismaQueryParser, PrismaQueryParserOptions, RelationMetadata, RepositoryLike, SchemaMetadata, ValidationResult, createMongooseAdapter, createPrismaAdapter };
+import { At as SchemaMetadata, Dt as FieldMetadata, Et as DataAdapter, Ot as RelationMetadata, jt as ValidationResult, kt as RepositoryLike, wt as AdapterFactory } from "../index-Cl0uoKd5.mjs";
+import { a as PrismaQueryParserOptions, c as MongooseAdapterOptions, d as DrizzleAdapterOptions, f as createDrizzleAdapter, i as PrismaQueryParser, l as createMongooseAdapter, n as PrismaAdapterOptions, o as createPrismaAdapter, r as PrismaQueryOptions, s as MongooseAdapter, t as PrismaAdapter, u as DrizzleAdapter } from "../index-DStwgFUK.mjs";
+export { AdapterFactory, DataAdapter, DrizzleAdapter, DrizzleAdapterOptions, FieldMetadata, MongooseAdapter, MongooseAdapterOptions, PrismaAdapter, PrismaAdapterOptions, PrismaQueryOptions, PrismaQueryParser, PrismaQueryParserOptions, RelationMetadata, RepositoryLike, SchemaMetadata, ValidationResult, createDrizzleAdapter, createMongooseAdapter, createPrismaAdapter };

package/dist/adapters/index.mjs

@@ -1,2 +1,2 @@
-import { a as createMongooseAdapter, i as MongooseAdapter, n as PrismaQueryParser, r as createPrismaAdapter, t as PrismaAdapter } from "../adapters-BBqAVvPK.mjs";
-export { MongooseAdapter, PrismaAdapter, PrismaQueryParser, createMongooseAdapter, createPrismaAdapter };
+import { a as createMongooseAdapter, i as MongooseAdapter, n as PrismaQueryParser, o as DrizzleAdapter, r as createPrismaAdapter, s as createDrizzleAdapter, t as PrismaAdapter } from "../adapters-BXY4i-hw.mjs";
+export { DrizzleAdapter, MongooseAdapter, PrismaAdapter, PrismaQueryParser, createDrizzleAdapter, createMongooseAdapter, createPrismaAdapter };

package/dist/{adapters-BBqAVvPK.mjs → adapters-BXY4i-hw.mjs}

@@ -1,4 +1,44 @@
-import { h as SYSTEM_FIELDS, m as RESERVED_QUERY_PARAMS } from "./constants-Cxde4rpC.mjs";
+import { h as SYSTEM_FIELDS, m as RESERVED_QUERY_PARAMS } from "./constants-BhY1OHoH.mjs";
+//#region src/adapters/field-rule-helpers.ts
+/**
+* Merge constraint-style `fieldRules` into an `OpenApiSchemas` bag in place.
+*
+* Operates on the three schema slots that carry property maps — `createBody`,
+* `updateBody`, `response`. `listQuery` and `params` are skipped (their
+* constraint vocabulary is owned by the kit's query parser).
+*
+* Existing constraints on a property always win — the merge only fills in
+* gaps. Adapters that already walk `fieldRules` during base-schema assembly
+* can call this helper for free (the checks are no-ops when constraints
+* already exist).
+*/
+function mergeFieldRuleConstraints(schemas, schemaOptions) {
+	if (!schemas || typeof schemas !== "object") return;
+	const rules = schemaOptions?.fieldRules;
+	if (!rules || Object.keys(rules).length === 0) return;
+	for (const slot of [
+		"createBody",
+		"updateBody",
+		"response"
+	]) {
+		const slotSchema = schemas[slot];
+		if (!slotSchema || typeof slotSchema !== "object") continue;
+		const properties = slotSchema.properties;
+		if (!properties) continue;
+		for (const [field, rule] of Object.entries(rules)) {
+			const prop = properties[field];
+			if (!prop || typeof prop !== "object") continue;
+			if (rule.minLength != null && prop.minLength == null) prop.minLength = rule.minLength;
+			if (rule.maxLength != null && prop.maxLength == null) prop.maxLength = rule.maxLength;
+			if (rule.min != null && prop.minimum == null) prop.minimum = rule.min;
+			if (rule.max != null && prop.maximum == null) prop.maximum = rule.max;
+			if (rule.pattern != null && prop.pattern == null) prop.pattern = rule.pattern;
+			if (rule.enum != null && prop.enum == null) prop.enum = rule.enum;
+			if (rule.description != null && prop.description == null) prop.description = rule.description;
+		}
+	}
+}
+//#endregion
 //#region src/adapters/types.ts
 /**
 * Check if value is a Mongoose model
@@ -13,6 +53,168 @@ function isRepository(value) {
 	return typeof value === "object" && value !== null && "getAll" in value && "getById" in value && "create" in value && "update" in value && "delete" in value;
 }
 //#endregion
+//#region src/adapters/drizzle.ts
+const DRIZZLE_COLUMNS_SYMBOL = Symbol.for("drizzle:Columns");
+function getColumns(table) {
+	const cols = table[DRIZZLE_COLUMNS_SYMBOL];
+	if (!cols || typeof cols !== "object") return {};
+	return cols;
+}
+function columnToJsonSchema(column) {
+	const { dataType, columnType, enumValues, length } = column;
+	if (dataType === "date") return {
+		type: "string",
+		format: "date-time"
+	};
+	if (dataType === "boolean") return { type: "boolean" };
+	if (dataType === "json") return {
+		type: "object",
+		additionalProperties: true
+	};
+	if (dataType === "buffer") return {
+		type: "string",
+		contentEncoding: "base64"
+	};
+	if (dataType === "number" || dataType === "bigint") return { type: columnType === "SQLiteInteger" ? "integer" : "number" };
+	if (dataType === "string") {
+		const result = { type: "string" };
+		if (Array.isArray(enumValues) && enumValues.length > 0) result.enum = [...enumValues];
+		if (typeof length === "number" && length > 0) result.maxLength = length;
+		return result;
+	}
+	return {};
+}
+function columnToFieldMetadata(column) {
+	const { dataType, enumValues } = column;
+	const meta = {
+		type: (dataType && {
+			number: "number",
+			bigint: "number",
+			string: "string",
+			date: "date",
+			boolean: "boolean",
+			json: "object",
+			buffer: "object"
+		}[dataType]) ?? (enumValues?.length ? "enum" : "object"),
+		required: !!column.notNull && !column.hasDefault
+	};
+	if (enumValues?.length) meta.enum = [...enumValues];
+	if (typeof column.length === "number") meta.maxLength = column.length;
+	return meta;
+}
+var DrizzleAdapter = class {
+	type = "drizzle";
+	name;
+	table;
+	repository;
+	schemaGenerator;
+	constructor(options) {
+		if (!options.table || typeof options.table !== "object") throw new TypeError("DrizzleAdapter: Invalid table. Expected a Drizzle table created with sqliteTable / pgTable / mysqlTable.");
+		if (!isRepository(options.repository)) throw new TypeError("DrizzleAdapter: Invalid repository. Expected an object implementing MinimalRepo (getAll / getById / create / update / delete).");
+		this.table = options.table;
+		this.repository = options.repository;
+		this.schemaGenerator = options.schemaGenerator;
+		this.name = options.name ?? "DrizzleAdapter";
+	}
+	/**
+	* Introspect Drizzle columns into arc's schema metadata shape.
+	*/
+	getSchemaMetadata() {
+		const columns = getColumns(this.table);
+		const fields = {};
+		const indexes = [];
+		for (const [name, column] of Object.entries(columns)) {
+			fields[name] = columnToFieldMetadata(column);
+			if (column.primary) indexes.push({
+				fields: [name],
+				unique: true
+			});
+		}
+		return {
+			name: this.name,
+			fields,
+			...indexes.length > 0 ? { indexes } : {}
+		};
+	}
+	/**
+	* Generate OpenAPI schemas. Delegates to the user-provided
+	* `schemaGenerator` when available (strongly recommended — that's where
+	* field rules, omit lists, and param-type narrowing live). The built-in
+	* fallback emits a permissive entity + CRUD body shape so routes still
+	* register when no generator is provided.
+	*
+	* After the kit generator runs, arc merges constraint-style field rules
+	* (`minLength`, `maxLength`, `min`, `max`, `pattern`, `enum`, `description`)
+	* into the resulting property schemas so sqlitekit / pgkit behave
+	* identically to mongoose here — rule-driven AJV constraints apply
+	* regardless of backend.
+	*/
+	generateSchemas(schemaOptions, context) {
+		try {
+			if (this.schemaGenerator) {
+				const generated = this.schemaGenerator(this.table, schemaOptions, context);
+				mergeFieldRuleConstraints(generated, schemaOptions);
+				return generated;
+			}
+			const columns = getColumns(this.table);
+			if (Object.keys(columns).length === 0) return null;
+			const entityProperties = {};
+			const inputProperties = {};
+			const inputRequired = [];
+			const updateProperties = {};
+			const fieldRules = schemaOptions?.fieldRules ?? {};
+			const readonlySet = new Set(schemaOptions?.readonlyFields ?? []);
+			const optionalSet = new Set(schemaOptions?.optionalFields ?? []);
+			const blocked = new Set([
+				...Object.entries(fieldRules).filter(([, rules]) => rules.systemManaged || rules.hidden).map(([field]) => field),
+				...schemaOptions?.excludeFields ?? [],
+				...schemaOptions?.hiddenFields ?? []
+			]);
+			for (const [fieldName, column] of Object.entries(columns)) {
+				const schema = columnToJsonSchema(column);
+				entityProperties[fieldName] = schema;
+				if (blocked.has(fieldName)) continue;
+				if (column.primary && column.columnType === "SQLiteInteger") continue;
+				if (!readonlySet.has(fieldName)) {
+					inputProperties[fieldName] = schema;
+					if (!!column.notNull && !column.hasDefault && !optionalSet.has(fieldName)) inputRequired.push(fieldName);
+					updateProperties[fieldName] = schema;
+				}
+			}
+			return {
+				createBody: {
+					type: "object",
+					properties: inputProperties,
+					required: inputRequired.length > 0 ? inputRequired : void 0,
+					additionalProperties: true
+				},
+				updateBody: {
+					type: "object",
+					properties: updateProperties,
+					additionalProperties: true
+				},
+				response: {
+					type: "object",
+					properties: entityProperties,
+					additionalProperties: true
+				}
+			};
+		} catch {
+			return null;
+		}
+	}
+	async healthCheck() {
+		return typeof this.repository.getAll === "function";
+	}
+};
+/**
+* Factory — preferred construction style for symmetry with
+* `createMongooseAdapter` / `createPrismaAdapter`.
+*/
+function createDrizzleAdapter(options) {
+	return new DrizzleAdapter(options);
+}
+//#endregion
 //#region src/adapters/mongoose.ts
 /**
 * Mongoose data adapter with proper type safety
@@ -27,7 +229,7 @@ var MongooseAdapter = class {
 	schemaGenerator;
 	constructor(options) {
 		if (!isMongooseModel(options.model)) throw new TypeError("MongooseAdapter: Invalid model. Expected Mongoose Model instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
-		if (!isRepository(options.repository)) throw new TypeError("MongooseAdapter: Invalid repository. Expected CrudRepository instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
+		if (!isRepository(options.repository)) throw new TypeError("MongooseAdapter: Invalid repository. Expected StandardRepo instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
 		this.model = options.model;
 		this.repository = options.repository;
 		this.schemaGenerator = options.schemaGenerator;
@@ -73,7 +275,11 @@ var MongooseAdapter = class {
 	*/
 	generateSchemas(schemaOptions, context) {
 		try {
-			if (this.schemaGenerator) return this.schemaGenerator(this.model, schemaOptions, context);
+			if (this.schemaGenerator) {
+				const generated = this.schemaGenerator(this.model, schemaOptions, context);
+				mergeFieldRuleConstraints(generated, schemaOptions);
+				return generated;
+			}
 			const paths = this.model.schema.paths;
 			const properties = {};
 			const required = [];
@@ -242,43 +448,6 @@ function createMongooseAdapter(modelOrOptions, repository) {
 //#endregion
 //#region src/adapters/prisma.ts
 /**
-* Prisma Adapter - PostgreSQL/MySQL/SQLite Implementation
-*
-* @experimental This adapter is implemented but has no integration tests yet.
-* Use in production at your own risk. The Mongoose adapter is the recommended
-* and battle-tested path.
-*
-* Bridges Prisma Client with Arc's DataAdapter interface.
-* Supports Prisma 5+ with all database providers.
-*
-* Implemented features:
-* - Schema generation (OpenAPI docs from DMMF)
-* - Health checks (database connectivity)
-* - Query parsing (URL params → Prisma where/orderBy)
-* - Policy filter translation
-* - Soft delete preset support
-*
-* Known gaps:
-* - No integration test coverage
-* - Multi-tenant isolation relies on caller-provided policyFilters (no auto-enforcement)
-*
-* @example
-* ```typescript
-* import { PrismaClient, Prisma } from '@prisma/client';
-* import { createPrismaAdapter, PrismaQueryParser } from '@classytic/arc/adapters';
-*
-* const prisma = new PrismaClient();
-*
-* const userAdapter = createPrismaAdapter({
-*   client: prisma,
-*   modelName: 'user',
-*   repository: new UserRepository(prisma),
-*   dmmf: Prisma.dmmf, // For schema generation
-*   queryParser: new PrismaQueryParser(), // Optional: custom parser
-* });
-* ```
-*/
-/**
 * Prisma Query Parser - Converts URL parameters to Prisma query format
 *
 * Translates Arc's query format to Prisma's where/orderBy/take/skip structure.
@@ -723,4 +892,4 @@ function createPrismaAdapter(options) {
 	return new PrismaAdapter(options);
 }
 //#endregion
-export { createMongooseAdapter as a, MongooseAdapter as i, PrismaQueryParser as n, createPrismaAdapter as r, PrismaAdapter as t };
+export { createMongooseAdapter as a, MongooseAdapter as i, PrismaQueryParser as n, DrizzleAdapter as o, createPrismaAdapter as r, createDrizzleAdapter as s, PrismaAdapter as t };