typion 0.0.0-stage → 0.1.1

package/dist/contract/index.d.ts

@@ -0,0 +1,137 @@
+import { $a as InferItem, $r as NoneIfEmpty, C as WireBatchEnvelope, D as WireErrorCode, Dr as TraitOptions, E as WireError, Mr as CreateOptions, Nr as DeleteOptions, O as WireErrorEnvelope, Or as TraitQueries, Qa as Descriptor, Qr as NoExtraKeys, S as ErrorStatus, T as WireEnvelope, U as TypionDefinition, Wa as TypionErrorCode, Wr as Id, Yr as LinkQueries, Za as AnyDescriptor, ai as UpdateInput, ao as descriptor, eo as InferResult, gi as Page, io as WriteOp, jr as CreateInput, k as WireIssue, m as TypionTypes, mi as InputSchema, no as RESULT, oi as UpdateManyOptions, ri as Row, ro as ReadOp, si as UpdateOptions, ti as ReadRow, to as Op, u as EntityName, vi as Result, w as WireDataEnvelope, wr as Jsonified, x as ERROR_STATUS, xa as PluginReadOptions } from "../context-B4e2eREP.js";
+import { AnyRelations, GetTableViewFieldSelection, KnownKeysOnly } from "drizzle-orm";
+//#region src/contract/wire.d.ts
+type ColData<C> = C extends {
+  _: {
+    data: infer D;
+  };
+} ? D : unknown;
+type TargetOf<TRel> = TRel extends {
+  targetTableName: infer T extends string;
+} ? T : never;
+type KindOf<TRel> = TRel extends {
+  relationType: infer RT;
+} ? RT : never;
+type Cols<S extends AnyRelations, N extends keyof S> = GetTableViewFieldSelection<S[N]['table']>;
+type WireSchema<TE extends TypionTypes> = InputSchema<TE, 'user'>;
+type WireFieldFilter<T> = {
+  eq?: T;
+  ne?: T;
+  gt?: T;
+  gte?: T;
+  lt?: T;
+  lte?: T;
+  in?: T[];
+  notIn?: T[];
+  like?: string;
+  ilike?: string;
+  notLike?: string;
+  notIlike?: string;
+  isNull?: true;
+  isNotNull?: true;
+  NOT?: WireFieldFilter<T>;
+  OR?: WireFieldFilter<T>[];
+  AND?: WireFieldFilter<T>[];
+} | (T extends object ? never : T);
+type WireWhere<S extends AnyRelations, N extends keyof S> = { [K in keyof Cols<S, N>]?: WireFieldFilter<NonNullable<ColData<Cols<S, N>[K]>>> | undefined; } & { [K in keyof S[N]['relations']]?: boolean | WireWhere<S, TargetOf<S[N]['relations'][K]> & keyof S> | undefined; } & {
+  AND?: WireWhere<S, N>[] | undefined;
+  OR?: WireWhere<S, N>[] | undefined;
+  NOT?: WireWhere<S, N> | undefined;
+};
+type WireWith<S extends AnyRelations, N extends keyof S> = { [K in keyof S[N]['relations']]?: boolean | WireConfig<S, TargetOf<S[N]['relations'][K]> & keyof S, KindOf<S[N]['relations'][K]>> | undefined; };
+type WireConfig<S extends AnyRelations, N extends keyof S, TKind> = {
+  columns?: { [K in keyof Cols<S, N>]?: boolean | undefined; } | undefined;
+  where?: WireWhere<S, N> | undefined;
+  orderBy?: { [K in keyof Cols<S, N>]?: 'asc' | 'desc' | undefined; } | undefined;
+  offset?: number | undefined;
+} & (keyof S[N]['relations'] extends never ? {} : {
+  with?: WireWith<S, N> | undefined;
+}) & (TKind extends 'many' ? {
+  limit?: number | undefined;
+} : {});
+type WireReadOptions<TE extends TypionTypes, N extends EntityName<TE>> = PluginReadOptions<TE['plugins']> & TraitOptions<TE['plugins'], TE['entities'][N]['options'], 'read'>;
+type WireFindConfig<TE extends TypionTypes, N extends EntityName<TE>> = WireConfig<WireSchema<TE>, N, 'many'> & WireReadOptions<TE, N>;
+type WireFirstConfig<TE extends TypionTypes, N extends EntityName<TE>> = WireConfig<WireSchema<TE>, N, 'one'> & WireReadOptions<TE, N>;
+type WireByIdConfig<TE extends TypionTypes, N extends EntityName<TE>> = Omit<WireFirstConfig<TE, N>, 'where' | 'offset'>;
+type WireCountConfig<TE extends TypionTypes, N extends EntityName<TE>> = {
+  where?: WireWhere<WireSchema<TE>, N> | undefined;
+} & WireReadOptions<TE, N>;
+type WireIdInput<TE extends TypionTypes, N extends EntityName<TE>> = {
+  id: Id<TE, N>;
+};
+type WireCreateInput<TE extends TypionTypes, N extends EntityName<TE>, O = {}> = {
+  data: CreateInput<TE, N, O, 'user'>;
+  options?: O & CreateOptions<TE, N> & NoExtraKeys<O, CreateOptions<TE, N>>;
+};
+type WireUpdateInput<TE extends TypionTypes, N extends EntityName<TE>, O = {}> = {
+  id: Id<TE, N>;
+  data: UpdateInput<TE, N, O, 'user'>;
+  options?: O & UpdateOptions<TE, N> & NoExtraKeys<O, UpdateOptions<TE, N>>;
+};
+type WireUpdateManyInput<TE extends TypionTypes, N extends EntityName<TE>, O = {}> = {
+  where: WireWhere<WireSchema<TE>, N>;
+  data: UpdateInput<TE, N, O, 'user'>;
+  options?: O & UpdateManyOptions<TE, N> & NoExtraKeys<O, UpdateManyOptions<TE, N>>;
+};
+type WireDeleteInput<TE extends TypionTypes, N extends EntityName<TE>> = {
+  id: Id<TE, N>;
+  options?: NoneIfEmpty<DeleteOptions<TE, N>>;
+};
+type WireDeleteManyInput<TE extends TypionTypes, N extends EntityName<TE>> = {
+  where: WireWhere<WireSchema<TE>, N>;
+  options?: {
+    max?: number;
+  } & DeleteOptions<TE, N>;
+};
+type WireWriteInputs<TE extends TypionTypes, N extends EntityName<TE>> = {
+  create: WireCreateInput<TE, N>;
+  update: WireUpdateInput<TE, N>;
+  updateMany: WireUpdateManyInput<TE, N>;
+  delete: WireDeleteInput<TE, N>;
+  deleteMany: WireDeleteManyInput<TE, N>;
+};
+type WireReadInputs<TE extends TypionTypes, N extends EntityName<TE>> = {
+  find: WireFindConfig<TE, N>;
+  findOne: WireFirstConfig<TE, N>;
+  findById: {
+    id: Id<TE, N>;
+    config?: WireByIdConfig<TE, N>;
+  };
+  count: WireCountConfig<TE, N>;
+  page: WireFindConfig<TE, N>;
+};
+//#endregion
+//#region src/contract/define-queries-types.d.ts
+type AppTypes<App> = App extends {
+  readonly $def: TypionDefinition<infer TE extends TypionTypes>;
+} ? TE : never;
+interface QueryApi<TE extends TypionTypes, N extends EntityName<TE>> {
+  find<const C extends WireFindConfig<TE, N>>(config: KnownKeysOnly<C, WireFindConfig<TE, N>>): Descriptor<N, 'find', C, Result<TE, N, C, 'user'>[]>;
+  findOne<const C extends WireFirstConfig<TE, N>>(config: KnownKeysOnly<C, WireFirstConfig<TE, N>>): Descriptor<N, 'findOne', C, Result<TE, N, C, 'user'> | null>;
+  findById<const C extends WireByIdConfig<TE, N>>(input: {
+    id: WireIdInput<TE, N>['id'];
+    config?: KnownKeysOnly<C, WireByIdConfig<TE, N>>;
+  }): Descriptor<N, 'findById', {
+    id: WireIdInput<TE, N>['id'];
+    config?: C;
+  }, Result<TE, N, C, 'user'>>;
+  count(config: WireCountConfig<TE, N>): Descriptor<N, 'count', WireCountConfig<TE, N>, number>;
+  page<const C extends WireFindConfig<TE, N>>(config: KnownKeysOnly<C, WireFindConfig<TE, N>>): Descriptor<N, 'page', C, Page<Result<TE, N, C, 'user'>>>;
+  create<const O extends CreateOptions<TE, N>>(input: WireCreateInput<TE, N, O>): Descriptor<N, 'create', WireCreateInput<TE, N, O>, ReadRow<TE, N, O>>;
+  update<const O extends UpdateOptions<TE, N>>(input: WireUpdateInput<TE, N, O>): Descriptor<N, 'update', WireUpdateInput<TE, N, O>, ReadRow<TE, N, O>>;
+  updateMany<const O extends UpdateManyOptions<TE, N>>(input: WireUpdateManyInput<TE, N, O>): Descriptor<N, 'updateMany', WireUpdateManyInput<TE, N, O>, {
+    count: number;
+  }>;
+  delete(input: WireDeleteInput<TE, N>): Descriptor<N, 'delete', WireDeleteInput<TE, N>, Row<TE, N>>;
+  deleteMany(input: WireDeleteManyInput<TE, N>): Descriptor<N, 'deleteMany', WireDeleteManyInput<TE, N>, {
+    count: number;
+  }>;
+}
+type QueriesOf<TE extends TypionTypes> = { [N in EntityName<TE>]: QueryApi<TE, N> & TraitQueries<TE, N> & LinkQueries<TE, N>; };
+type Queries<App> = [AppTypes<App>] extends [never] ? never : QueriesOf<AppTypes<App>>;
+//#endregion
+//#region src/contract/define-queries.d.ts
+export declare function defineQueries<App>(): Queries<App>;
+//#endregion
+export { type AnyDescriptor, type AppTypes, type Descriptor, ERROR_STATUS, type ErrorStatus, type InferItem, type InferResult, type Jsonified, type Op, type Queries, type QueriesOf, type QueryApi, type RESULT, type ReadOp, type TypionErrorCode, type WireBatchEnvelope, type WireByIdConfig, type WireConfig, type WireCountConfig, type WireCreateInput, type WireDataEnvelope, type WireDeleteInput, type WireDeleteManyInput, type WireEnvelope, type WireError, type WireErrorCode, type WireErrorEnvelope, type WireFieldFilter, type WireFindConfig, type WireFirstConfig, type WireIdInput, type WireIssue, type WireReadInputs, type WireReadOptions, type WireSchema, type WireUpdateInput, type WireUpdateManyInput, type WireWhere, type WireWith, type WireWriteInputs, type WriteOp, descriptor };
+//# sourceMappingURL=index.d.ts.map

package/dist/contract/index.js

@@ -0,0 +1,42 @@
+import { t as descriptor } from "../descriptor-Cc3mGp73.js";
+import { t as ERROR_STATUS } from "../errors-ChDBxeS-.js";
+//#region src/contract/define-queries.ts
+function opFactory(entity, op) {
+	const make = (input) => ({
+		entity,
+		op,
+		input: input ?? {}
+	});
+	return new Proxy(make, { get(target, key) {
+		if (typeof key !== "string" || key in target || key === "then") return Reflect.get(target, key);
+		return opFactory(entity, `${op}.${key}`);
+	} });
+}
+function entityQueries(entity) {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get(_target, op) {
+		if (typeof op !== "string" || op === "then") return void 0;
+		let factory = cache.get(op);
+		if (factory === void 0) {
+			factory = opFactory(entity, op);
+			cache.set(op, factory);
+		}
+		return factory;
+	} });
+}
+function defineQueries() {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get(_target, entity) {
+		if (typeof entity !== "string") return void 0;
+		let api = cache.get(entity);
+		if (api === void 0) {
+			api = entityQueries(entity);
+			cache.set(entity, api);
+		}
+		return api;
+	} });
+}
+//#endregion
+export { ERROR_STATUS, defineQueries, descriptor };
+
+//# sourceMappingURL=index.js.map

package/dist/contract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/contract/define-queries.ts"],"sourcesContent":["import type { Queries } from './define-queries-types.js'\nimport type { AnyDescriptor } from './descriptor.js'\n\n// Every method name is an op, and a nested one joins with a dot (`versions.list`): the client knows neither\n// the engine nor its plugins, so `restore` on an entity whose plugin adds it is built like any other.\nfunction opFactory(entity: string, op: string): unknown {\n  const make = (input: unknown): AnyDescriptor => ({ entity, op, input: input ?? {} })\n  return new Proxy(make, {\n    get(target, key) {\n      // A function's own members stay what they are, and a factory is never a thenable.\n      if (typeof key !== 'string' || key in target || key === 'then')\n        return Reflect.get(target, key)\n      return opFactory(entity, `${op}.${key}`)\n    },\n  })\n}\n\nfunction entityQueries(entity: string) {\n  const cache = new Map<string, unknown>()\n  return new Proxy({} as Record<string, unknown>, {\n    get(_target, op) {\n      if (typeof op !== 'string' || op === 'then') return undefined\n      let factory = cache.get(op)\n      if (factory === undefined) {\n        factory = opFactory(entity, op)\n        cache.set(op, factory)\n      }\n      return factory\n    },\n  })\n}\n\n// The engine type is only referenced as a type argument, so a client bundle gets descriptors with exact\n// result types and none of the server code (no Drizzle, no engine runtime).\nexport function defineQueries<App>(): Queries<App> {\n  const cache = new Map<string, unknown>()\n  return new Proxy({} as Record<string, unknown>, {\n    get(_target, entity) {\n      if (typeof entity !== 'string') return undefined\n      let api = cache.get(entity)\n      if (api === undefined) {\n        api = entityQueries(entity)\n        cache.set(entity, api)\n      }\n      return api\n    },\n  }) as unknown as Queries<App>\n}\n"],"mappings":";;;AAKA,SAAS,UAAU,QAAgB,IAAqB;CACtD,MAAM,QAAQ,WAAmC;EAAE;EAAQ;EAAI,OAAO,SAAS,CAAC;CAAE;CAClF,OAAO,IAAI,MAAM,MAAM,EACrB,IAAI,QAAQ,KAAK;EAEf,IAAI,OAAO,QAAQ,YAAY,OAAO,UAAU,QAAQ,QACtD,OAAO,QAAQ,IAAI,QAAQ,GAAG;EAChC,OAAO,UAAU,QAAQ,GAAG,GAAG,GAAG,KAAK;CACzC,EACF,CAAC;AACH;AAEA,SAAS,cAAc,QAAgB;CACrC,MAAM,wBAAQ,IAAI,IAAqB;CACvC,OAAO,IAAI,MAAM,CAAC,GAA8B,EAC9C,IAAI,SAAS,IAAI;EACf,IAAI,OAAO,OAAO,YAAY,OAAO,QAAQ,OAAO,KAAA;EACpD,IAAI,UAAU,MAAM,IAAI,EAAE;EAC1B,IAAI,YAAY,KAAA,GAAW;GACzB,UAAU,UAAU,QAAQ,EAAE;GAC9B,MAAM,IAAI,IAAI,OAAO;EACvB;EACA,OAAO;CACT,EACF,CAAC;AACH;AAIA,SAAgB,gBAAmC;CACjD,MAAM,wBAAQ,IAAI,IAAqB;CACvC,OAAO,IAAI,MAAM,CAAC,GAA8B,EAC9C,IAAI,SAAS,QAAQ;EACnB,IAAI,OAAO,WAAW,UAAU,OAAO,KAAA;EACvC,IAAI,MAAM,MAAM,IAAI,MAAM;EAC1B,IAAI,QAAQ,KAAA,GAAW;GACrB,MAAM,cAAc,MAAM;GAC1B,MAAM,IAAI,QAAQ,GAAG;EACvB;EACA,OAAO;CACT,EACF,CAAC;AACH"}

package/dist/db/pglite.d.ts

@@ -0,0 +1,12 @@
+import { Kt as DbAdapter } from "../context-B4e2eREP.js";
+import { PGlite } from "@electric-sql/pglite";
+//#region src/db/pglite.d.ts
+export type PgliteAdapter = DbAdapter & {
+  client(): PGlite;
+};
+export declare function pglite(options?: {
+  dataDir?: string;
+  client?: PGlite;
+}): PgliteAdapter;
+//#endregion
+//# sourceMappingURL=pglite.d.ts.map

package/dist/db/pglite.js

@@ -0,0 +1,27 @@
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+//#region src/db/pglite.ts
+function pglite(options = {}) {
+	let client = options.client;
+	const open = () => client ??= new PGlite(options.dataDir);
+	return {
+		client: open,
+		connect: (relations) => drizzle({
+			client: open(),
+			relations
+		}),
+		credentials: () => ({
+			driver: "pglite",
+			client: open()
+		}),
+		close: async () => {
+			const opened = client;
+			client = void 0;
+			await opened?.close();
+		}
+	};
+}
+//#endregion
+export { pglite };
+
+//# sourceMappingURL=pglite.js.map

package/dist/db/pglite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pglite.js","names":[],"sources":["../../src/db/pglite.ts"],"sourcesContent":["import { PGlite } from '@electric-sql/pglite'\nimport { drizzle } from 'drizzle-orm/pglite'\nimport type { DbAdapter } from '../types/collection.js'\n\nexport type PgliteAdapter = DbAdapter & { client(): PGlite }\n\n// In-process Postgres: no data directory means in memory, which is what tests use.\nexport function pglite(options: { dataDir?: string; client?: PGlite } = {}): PgliteAdapter {\n  let client = options.client\n  const open = () => (client ??= new PGlite(options.dataDir))\n  return {\n    client: open,\n    connect: (relations) => drizzle({ client: open(), relations }) as never,\n    credentials: () => ({ driver: 'pglite' as const, client: open() }),\n    close: async () => {\n      const opened = client\n      // Forgotten, so that a later connect opens a fresh database rather than the closed one.\n      client = undefined\n      await opened?.close()\n    },\n  }\n}\n"],"mappings":";;;AAOA,SAAgB,OAAO,UAAiD,CAAC,GAAkB;CACzF,IAAI,SAAS,QAAQ;CACrB,MAAM,aAAc,WAAW,IAAI,OAAO,QAAQ,OAAO;CACzD,OAAO;EACL,QAAQ;EACR,UAAU,cAAc,QAAQ;GAAE,QAAQ,KAAK;GAAG;EAAU,CAAC;EAC7D,oBAAoB;GAAE,QAAQ;GAAmB,QAAQ,KAAK;EAAE;EAChE,OAAO,YAAY;GACjB,MAAM,SAAS;GAEf,SAAS,KAAA;GACT,MAAM,QAAQ,MAAM;EACtB;CACF;AACF"}

package/dist/descriptor-Cc3mGp73.js

@@ -0,0 +1,12 @@
+//#region src/contract/descriptor.ts
+function descriptor(entity, op, input) {
+	return {
+		entity,
+		op,
+		input
+	};
+}
+//#endregion
+export { descriptor as t };
+
+//# sourceMappingURL=descriptor-Cc3mGp73.js.map

package/dist/descriptor-Cc3mGp73.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-Cc3mGp73.js","names":[],"sources":["../src/contract/descriptor.ts"],"sourcesContent":["// The phantom result key is declared exactly once, here. A second `declare const RESULT: unique symbol`\n// anywhere else is a different symbol and silently makes `InferResult` resolve to `unknown`.\nexport declare const RESULT: unique symbol\n\nexport type ReadOp = 'find' | 'findOne' | 'findById' | 'count' | 'page'\nexport type WriteOp = 'create' | 'update' | 'updateMany' | 'delete' | 'deleteMany'\n// An operation a plugin adds to the entities it acts on (`restore`, `versions.list`) is an op of its own name.\nexport type Op = ReadOp | WriteOp | (string & {})\n\nexport interface Descriptor<TEntity extends string, TOp extends Op, TInput, TResult> {\n  readonly entity: TEntity\n  readonly op: TOp\n  readonly input: TInput\n  readonly [RESULT]?: TResult\n}\n\nexport type AnyDescriptor = Descriptor<string, Op, unknown, unknown>\n\nexport type InferResult<Q> = Q extends { readonly [RESULT]?: infer T } ? T : never\n\nexport type InferItem<Q> =\n  InferResult<Q> extends readonly (infer El)[]\n    ? El\n    : InferResult<Q> extends { items: readonly (infer El)[] }\n      ? El\n      : NonNullable<InferResult<Q>>\n\nexport function descriptor<E extends string, O extends Op, I>(\n  entity: E,\n  op: O,\n  input: I,\n): Descriptor<E, O, I, unknown> {\n  return { entity, op, input }\n}\n"],"mappings":";AA2BA,SAAgB,WACd,QACA,IACA,OAC8B;CAC9B,OAAO;EAAE;EAAQ;EAAI;CAAM;AAC7B"}

package/dist/errors-ChDBxeS-.js

@@ -0,0 +1,17 @@
+//#region src/contract/errors.ts
+const ERROR_STATUS = {
+	NOT_FOUND: 404,
+	FORBIDDEN: 403,
+	VALIDATION: 422,
+	CONFLICT: 409,
+	INVALID_STATE: 409,
+	BAD_REQUEST: 400,
+	UNSUPPORTED: 400,
+	PLUGIN: 500,
+	CONFIG: 500,
+	INTERNAL: 500
+};
+//#endregion
+export { ERROR_STATUS as t };
+
+//# sourceMappingURL=errors-ChDBxeS-.js.map

package/dist/errors-ChDBxeS-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-ChDBxeS-.js","names":[],"sources":["../src/contract/errors.ts"],"sourcesContent":["import type { TypionErrorCode } from '../errors.js'\n\n// Shared by the HTTP handler and clients so status mapping never drifts between them. PLUGIN carries the\n// plugin-declared status at runtime; 500 is the fallback when a plugin declares none.\nexport const ERROR_STATUS = {\n  NOT_FOUND: 404,\n  FORBIDDEN: 403,\n  VALIDATION: 422,\n  CONFLICT: 409,\n  INVALID_STATE: 409,\n  BAD_REQUEST: 400,\n  UNSUPPORTED: 400,\n  PLUGIN: 500,\n  CONFIG: 500,\n  INTERNAL: 500,\n} as const satisfies Record<TypionErrorCode, number>\n\nexport type ErrorStatus = (typeof ERROR_STATUS)[TypionErrorCode]\n\nexport type WireIssue = { readonly path: readonly (string | number)[]; readonly message: string }\n\n// Over HTTP a refusal of a caller who has not signed in is `UNAUTHENTICATED` (401), so a client can tell \"sign in\" from\n// \"not allowed\"; in process it stays `FORBIDDEN`, since the server knows who calls.\nexport type WireErrorCode = TypionErrorCode | 'UNAUTHENTICATED'\n\nexport type WireError = {\n  readonly code: WireErrorCode\n  readonly status: number\n  readonly message: string\n  readonly entity?: string\n  readonly issues?: readonly WireIssue[]\n  readonly details?: Record<string, unknown>\n}\n\nexport type WireErrorEnvelope = { readonly error: WireError }\nexport type WireDataEnvelope<T> = { readonly data: T }\nexport type WireEnvelope<T> = WireDataEnvelope<T> | WireErrorEnvelope\nexport type WireBatchEnvelope<T = unknown> = { readonly results: readonly WireEnvelope<T>[] }\n"],"mappings":";AAIA,MAAa,eAAe;CAC1B,WAAW;CACX,WAAW;CACX,YAAY;CACZ,UAAU;CACV,eAAe;CACf,aAAa;CACb,aAAa;CACb,QAAQ;CACR,QAAQ;CACR,UAAU;AACZ"}

package/dist/errors-D-CKO-px.js

@@ -0,0 +1,114 @@
+//#region src/errors.ts
+var TypionError = class extends Error {
+	entity;
+	details;
+	constructor(message, opts = {}) {
+		super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+		this.name = new.target.name;
+		this.entity = opts.entity;
+		this.details = opts.details;
+	}
+};
+var NotFoundError = class extends TypionError {
+	code = "NOT_FOUND";
+	status = 404;
+};
+var ForbiddenError = class extends TypionError {
+	code = "FORBIDDEN";
+	status = 403;
+	operation;
+	rule;
+	constructor(message, opts = {}) {
+		super(message, opts);
+		this.operation = opts.operation;
+		this.rule = opts.rule;
+	}
+};
+var ValidationError = class extends TypionError {
+	code = "VALIDATION";
+	status = 422;
+	issues;
+	constructor(message, issues, opts = {}) {
+		super(message, opts);
+		this.issues = issues;
+	}
+};
+var ConflictError = class extends TypionError {
+	code = "CONFLICT";
+	status = 409;
+	kind;
+	constraint;
+	retryable;
+	constructor(message, kind, opts = {}) {
+		super(message, opts);
+		this.kind = kind;
+		this.constraint = opts.constraint;
+		this.retryable = opts.retryable ?? (kind === "serialization" || kind === "deadlock");
+		if (opts.issues !== void 0) this.issues = opts.issues;
+	}
+};
+var InvalidStateError = class extends TypionError {
+	code = "INVALID_STATE";
+	status = 409;
+};
+var BadRequestError = class extends TypionError {
+	code = "BAD_REQUEST";
+	status = 400;
+};
+var UnsupportedError = class extends TypionError {
+	code = "UNSUPPORTED";
+	status = 400;
+};
+var PluginError = class extends TypionError {
+	code = "PLUGIN";
+	status;
+	pluginId;
+	pluginCode;
+	constructor(message, pluginId, pluginCode, opts = {}) {
+		super(message, {
+			...opts,
+			details: {
+				...opts.details,
+				pluginId,
+				pluginCode
+			}
+		});
+		this.status = opts.status ?? 500;
+		this.pluginId = pluginId;
+		this.pluginCode = pluginCode;
+	}
+};
+var ConfigError = class extends TypionError {
+	code = "CONFIG";
+	status = 500;
+	kind;
+	constructor(message, kind = "config", opts = {}) {
+		super(message, opts);
+		this.kind = kind;
+	}
+};
+var InternalError = class extends TypionError {
+	code = "INTERNAL";
+	status = 500;
+};
+function isTypionError(e, code) {
+	return e instanceof TypionError && (code === void 0 || e.code === code);
+}
+async function attempt(fn) {
+	try {
+		return {
+			ok: true,
+			data: await fn()
+		};
+	} catch (error) {
+		if (isTypionError(error)) return {
+			ok: false,
+			error
+		};
+		throw error;
+	}
+}
+//#endregion
+export { InternalError as a, PluginError as c, ValidationError as d, attempt as f, ForbiddenError as i, TypionError as l, ConfigError as n, InvalidStateError as o, isTypionError as p, ConflictError as r, NotFoundError as s, BadRequestError as t, UnsupportedError as u };
+
+//# sourceMappingURL=errors-D-CKO-px.js.map

package/dist/errors-D-CKO-px.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-D-CKO-px.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export type TypionErrorCode =\n  | 'NOT_FOUND'\n  | 'FORBIDDEN'\n  | 'VALIDATION'\n  | 'CONFLICT'\n  | 'INVALID_STATE'\n  | 'BAD_REQUEST'\n  | 'UNSUPPORTED'\n  | 'PLUGIN'\n  | 'CONFIG'\n  | 'INTERNAL'\n\nexport type TypionErrorOptions = {\n  entity?: string\n  details?: Record<string, unknown>\n  cause?: unknown\n}\n\nexport abstract class TypionError extends Error {\n  abstract readonly code: TypionErrorCode\n  abstract readonly status: number\n  readonly entity: string | undefined\n  readonly details: Record<string, unknown> | undefined\n\n  constructor(message: string, opts: TypionErrorOptions = {}) {\n    super(message, opts.cause === undefined ? undefined : { cause: opts.cause })\n    this.name = new.target.name\n    this.entity = opts.entity\n    this.details = opts.details\n  }\n}\n\nexport class NotFoundError extends TypionError {\n  readonly code = 'NOT_FOUND' as const\n  readonly status = 404 as const\n}\n\nexport type ForbiddenErrorOptions = TypionErrorOptions & { operation?: string; rule?: string }\n\nexport class ForbiddenError extends TypionError {\n  readonly code = 'FORBIDDEN' as const\n  readonly status = 403 as const\n  readonly operation: string | undefined\n  readonly rule: string | undefined\n\n  constructor(message: string, opts: ForbiddenErrorOptions = {}) {\n    super(message, opts)\n    this.operation = opts.operation\n    this.rule = opts.rule\n  }\n}\n\nexport type ValidationIssue = { readonly path: readonly PropertyKey[]; readonly message: string }\n\nexport class ValidationError extends TypionError {\n  readonly code = 'VALIDATION' as const\n  readonly status = 422 as const\n  readonly issues: readonly ValidationIssue[]\n\n  constructor(message: string, issues: readonly ValidationIssue[], opts: TypionErrorOptions = {}) {\n    super(message, opts)\n    this.issues = issues\n  }\n}\n\nexport type ConflictKind = 'unique' | 'foreign_key' | 'check' | 'serialization' | 'deadlock'\n\nexport type ConflictErrorOptions = TypionErrorOptions & {\n  constraint?: string\n  retryable?: boolean\n  // The columns a unique or foreign key constraint covers, when the engine knows them.\n  issues?: readonly ValidationIssue[]\n}\n\nexport class ConflictError extends TypionError {\n  readonly code = 'CONFLICT' as const\n  readonly status = 409 as const\n  readonly kind: ConflictKind\n  readonly constraint: string | undefined\n  readonly retryable: boolean\n  // Declared, not initialized: an error without issues has no such key, which the wire reads.\n  declare readonly issues?: readonly ValidationIssue[]\n\n  constructor(message: string, kind: ConflictKind, opts: ConflictErrorOptions = {}) {\n    super(message, opts)\n    this.kind = kind\n    this.constraint = opts.constraint\n    this.retryable = opts.retryable ?? (kind === 'serialization' || kind === 'deadlock')\n    if (opts.issues !== undefined)\n      (this as { issues?: readonly ValidationIssue[] }).issues = opts.issues\n  }\n}\n\nexport class InvalidStateError extends TypionError {\n  readonly code = 'INVALID_STATE' as const\n  readonly status = 409 as const\n}\n\nexport class BadRequestError extends TypionError {\n  readonly code = 'BAD_REQUEST' as const\n  readonly status = 400 as const\n}\n\nexport class UnsupportedError extends TypionError {\n  readonly code = 'UNSUPPORTED' as const\n  readonly status = 400 as const\n}\n\nexport type PluginErrorOptions = TypionErrorOptions & { status?: number }\n\nexport class PluginError extends TypionError {\n  readonly code = 'PLUGIN' as const\n  readonly status: number\n  readonly pluginId: string\n  readonly pluginCode: string\n\n  constructor(\n    message: string,\n    pluginId: string,\n    pluginCode: string,\n    opts: PluginErrorOptions = {},\n  ) {\n    super(message, {\n      ...opts,\n      details: { ...opts.details, pluginId, pluginCode },\n    })\n    this.status = opts.status ?? 500\n    this.pluginId = pluginId\n    this.pluginCode = pluginCode\n  }\n}\n\nexport type ConfigErrorKind = 'config' | 'schema_drift' | 'relations_mismatch'\n\nexport class ConfigError extends TypionError {\n  readonly code = 'CONFIG' as const\n  readonly status = 500 as const\n  readonly kind: ConfigErrorKind\n\n  constructor(message: string, kind: ConfigErrorKind = 'config', opts: TypionErrorOptions = {}) {\n    super(message, opts)\n    this.kind = kind\n  }\n}\n\nexport class InternalError extends TypionError {\n  readonly code = 'INTERNAL' as const\n  readonly status = 500 as const\n}\n\nexport function isTypionError(e: unknown, code?: TypionErrorCode): e is TypionError {\n  return e instanceof TypionError && (code === undefined || e.code === code)\n}\n\nexport type Attempt<T> = { ok: true; data: T } | { ok: false; error: TypionError }\n\nexport async function attempt<T>(fn: () => Promise<T>): Promise<Attempt<T>> {\n  try {\n    return { ok: true, data: await fn() }\n  } catch (error) {\n    if (isTypionError(error)) return { ok: false, error }\n    throw error\n  }\n}\n"],"mappings":";AAkBA,IAAsB,cAAtB,cAA0C,MAAM;CAG9C;CACA;CAEA,YAAY,SAAiB,OAA2B,CAAC,GAAG;EAC1D,MAAM,SAAS,KAAK,UAAU,KAAA,IAAY,KAAA,IAAY,EAAE,OAAO,KAAK,MAAM,CAAC;EAC3E,KAAK,OAAO,WAAW;EACvB,KAAK,SAAS,KAAK;EACnB,KAAK,UAAU,KAAK;CACtB;AACF;AAEA,IAAa,gBAAb,cAAmC,YAAY;CAC7C,OAAgB;CAChB,SAAkB;AACpB;AAIA,IAAa,iBAAb,cAAoC,YAAY;CAC9C,OAAgB;CAChB,SAAkB;CAClB;CACA;CAEA,YAAY,SAAiB,OAA8B,CAAC,GAAG;EAC7D,MAAM,SAAS,IAAI;EACnB,KAAK,YAAY,KAAK;EACtB,KAAK,OAAO,KAAK;CACnB;AACF;AAIA,IAAa,kBAAb,cAAqC,YAAY;CAC/C,OAAgB;CAChB,SAAkB;CAClB;CAEA,YAAY,SAAiB,QAAoC,OAA2B,CAAC,GAAG;EAC9F,MAAM,SAAS,IAAI;EACnB,KAAK,SAAS;CAChB;AACF;AAWA,IAAa,gBAAb,cAAmC,YAAY;CAC7C,OAAgB;CAChB,SAAkB;CAClB;CACA;CACA;CAIA,YAAY,SAAiB,MAAoB,OAA6B,CAAC,GAAG;EAChF,MAAM,SAAS,IAAI;EACnB,KAAK,OAAO;EACZ,KAAK,aAAa,KAAK;EACvB,KAAK,YAAY,KAAK,cAAc,SAAS,mBAAmB,SAAS;EACzE,IAAI,KAAK,WAAW,KAAA,GAClB,KAAkD,SAAS,KAAK;CACpE;AACF;AAEA,IAAa,oBAAb,cAAuC,YAAY;CACjD,OAAgB;CAChB,SAAkB;AACpB;AAEA,IAAa,kBAAb,cAAqC,YAAY;CAC/C,OAAgB;CAChB,SAAkB;AACpB;AAEA,IAAa,mBAAb,cAAsC,YAAY;CAChD,OAAgB;CAChB,SAAkB;AACpB;AAIA,IAAa,cAAb,cAAiC,YAAY;CAC3C,OAAgB;CAChB;CACA;CACA;CAEA,YACE,SACA,UACA,YACA,OAA2B,CAAC,GAC5B;EACA,MAAM,SAAS;GACb,GAAG;GACH,SAAS;IAAE,GAAG,KAAK;IAAS;IAAU;GAAW;EACnD,CAAC;EACD,KAAK,SAAS,KAAK,UAAU;EAC7B,KAAK,WAAW;EAChB,KAAK,aAAa;CACpB;AACF;AAIA,IAAa,cAAb,cAAiC,YAAY;CAC3C,OAAgB;CAChB,SAAkB;CAClB;CAEA,YAAY,SAAiB,OAAwB,UAAU,OAA2B,CAAC,GAAG;EAC5F,MAAM,SAAS,IAAI;EACnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,gBAAb,cAAmC,YAAY;CAC7C,OAAgB;CAChB,SAAkB;AACpB;AAEA,SAAgB,cAAc,GAAY,MAA0C;CAClF,OAAO,aAAa,gBAAgB,SAAS,KAAA,KAAa,EAAE,SAAS;AACvE;AAIA,eAAsB,QAAW,IAA2C;CAC1E,IAAI;EACF,OAAO;GAAE,IAAI;GAAM,MAAM,MAAM,GAAG;EAAE;CACtC,SAAS,OAAO;EACd,IAAI,cAAc,KAAK,GAAG,OAAO;GAAE,IAAI;GAAO;EAAM;EACpD,MAAM;CACR;AACF"}

package/dist/handler-BWVU8TCR.d.ts

@@ -0,0 +1,23 @@
+import { d as HandlerOptions, m as TypionTypes, p as TypionEngine } from "./context-B4e2eREP.js";
+//#region src/http/handler.d.ts
+declare function typionErrorResponse(error: unknown, options?: {
+  debug?: boolean;
+  caller?: {
+    readonly $ctx: {
+      readonly actorId: string | null;
+    };
+  };
+}): Response;
+declare function createHandler<TE extends TypionTypes>(engine: TypionEngine<TE>, options: HandlerOptions<TE>): (request: Request) => Promise<Response>;
+type RouteHandlers = {
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+  PATCH: (request: Request) => Promise<Response>;
+  PUT: (request: Request) => Promise<Response>;
+  DELETE: (request: Request) => Promise<Response>;
+  OPTIONS: (request: Request) => Promise<Response>;
+};
+declare function toRouteHandlers(handler: (request: Request) => Promise<Response>): RouteHandlers;
+//#endregion
+export { typionErrorResponse as i, createHandler as n, toRouteHandlers as r, RouteHandlers as t };
+//# sourceMappingURL=handler-BWVU8TCR.d.ts.map