ignotum 0.0.0 → 0.0.2

package/dist/runtime/index-BgWROoyk.d.ts

@@ -0,0 +1,249 @@
+import { n as ErrorBrand, r as ErrorValue, s as Result, t as DocumentNotFoundValue } from "./result-C1ZdsM6Y.js";
+import { Brand, Effect, Schema } from "effect";
+//#region ../contracts/dist/id-BD_sn1pR.d.ts
+declare const GeneratedId: Schema.brand<Schema.String, "ignotum/id">;
+type GeneratedId = typeof GeneratedId.Type;
+//#endregion
+//#region ../contracts/dist/types-C3kZpWHV.d.ts
+//#region src/schema/types.d.ts
+/** A document identifier branded with the table it belongs to. */
+type Id<TableName extends string> = GeneratedId & Brand.Brand<`ignotum/id/${TableName}`>;
+declare const SchemaDefinitionTypeId: unique symbol;
+interface SchemaDefinitionContract<Definition> {
+  readonly [SchemaDefinitionTypeId]: Definition;
+}
+type SchemaDefinitionOf<SchemaDefinition> = SchemaDefinition extends SchemaDefinitionContract<infer Definition> ? Definition : never;
+interface TableDefinitionLike {
+  readonly fields: Schema.Struct.Fields;
+}
+interface TablesLike {
+  readonly [tableName: string]: TableDefinitionLike;
+}
+type TableNameOf$1<Definition extends TablesLike> = keyof Definition & string;
+interface SystemFields<TableName extends string> {
+  readonly id: Id<TableName>;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+}
+type DocumentFields<TableName extends string, Table extends TableDefinitionLike> = SystemFields<TableName> & Schema.Struct.Type<Table["fields"]>;
+/** The complete document returned for a table, including Ignotum system fields. */
+type Document<Definition extends TablesLike, TableName extends TableNameOf$1<Definition>> = { readonly [FieldName in keyof DocumentFields<TableName, Definition[TableName]>]: DocumentFields<TableName, Definition[TableName]>[FieldName]; };
+//#endregion
+//#region ../contracts/dist/schema/values.d.ts
+//#region src/schema/values.d.ts
+declare const IdTargetsTypeId: unique symbol;
+declare const UnresolvedReferencesTypeId: unique symbol;
+interface IdTargets<TableName extends string> {
+  readonly [IdTargetsTypeId]: TableName;
+}
+interface UnresolvedReferences<TableName extends string> {
+  readonly [UnresolvedReferencesTypeId]: TableName;
+}
+type IdTargetsOf<Value> = Value extends IdTargets<infer TableName> ? TableName : never;
+type UnresolvedReferencesOf<Value> = Value extends UnresolvedReferences<infer TableName> ? TableName : never;
+type WithIdTargets<Value, TableName extends string> = [TableName] extends [never] ? Value : Value & IdTargets<TableName>;
+type WithUnresolvedReferences<Value, TableName extends string> = [TableName] extends [never] ? Value : Value & UnresolvedReferences<TableName>;
+type PreserveIdMetadata<Value, Source> = WithUnresolvedReferences<WithIdTargets<Value, IdTargetsOf<Source>>, UnresolvedReferencesOf<Source>>;
+type IdDefinition<TableName extends string> = Schema.brand<typeof GeneratedId, `ignotum/id/${TableName}`> & IdTargets<TableName>;
+type ReferenceDefinition<TableName extends string> = IdDefinition<TableName> & UnresolvedReferences<TableName>;
+type LiteralValue = string | number | boolean;
+interface TableDefinition<Fields extends Schema.Struct.Fields> {
+  readonly _tag: "Table";
+  readonly fields: Fields;
+  readonly schema: Schema.Struct<Fields>;
+}
+type ReservedFieldName = "createdAt" | "id" | "updatedAt";
+type ReservedErrorTagName = "InternalServerError";
+declare const ReservedFieldTypeId: unique symbol;
+interface ReservedField<FieldName extends string> {
+  readonly [ReservedFieldTypeId]: `The field name '${FieldName}' is reserved by Ignotum`;
+}
+declare const ReservedErrorTagTypeId: unique symbol;
+interface ReservedErrorTag<Tag extends string> {
+  readonly [ReservedErrorTagTypeId]: `The error tag '${Tag}' is reserved by Ignotum`;
+}
+type ErrorTagValidation<Tag extends string> = Tag extends ReservedErrorTagName ? ReservedErrorTag<Tag> : unknown;
+type ReservedFieldValidation<Fields extends Schema.Struct.Fields> = { readonly [FieldName in Extract<keyof Fields, ReservedFieldName>]: ReservedField<FieldName>; };
+type ReservedErrorFieldValidation<Fields extends Schema.Struct.Fields> = { readonly [FieldName in Extract<keyof Fields, "_tag">]: ReservedField<FieldName>; };
+type ErrorDefinition<Tag extends string, Fields extends Schema.Struct.Fields> = PreserveIdMetadata<Schema.brand<Schema.TaggedStruct<Tag, Fields>, typeof ErrorBrand> & ((fields: Schema.Struct.MakeIn<Fields>) => Schema.brand<Schema.TaggedStruct<Tag, Fields>, typeof ErrorBrand>["Type"]), Fields[keyof Fields]>;
+declare const table: <const Fields extends Schema.Struct.Fields>(fields: Fields & ReservedFieldValidation<NoInfer<Fields>>) => TableDefinition<Fields>;
+declare const string: () => Schema.String;
+declare const number: () => Schema.Finite;
+declare const integer: () => Schema.Int;
+declare const boolean: () => Schema.Boolean;
+declare const date: () => Schema.DateFromMillis;
+declare const never: () => Schema.Never;
+declare const nullValue: () => Schema.Null;
+declare const literal: <const Value extends LiteralValue>(value: Value) => Schema.Literal<Value>;
+declare const literals: <const Members extends readonly [LiteralValue, LiteralValue, ...ReadonlyArray<LiteralValue>]>(...members: Members) => Schema.Literals<Members>;
+declare const id: <const TableName extends string>(tableName: TableName) => ReferenceDefinition<TableName>;
+declare const array: <Value extends Schema.Constraint>(value: Value) => PreserveIdMetadata<Schema.$Array<Value>, Value>;
+declare const object: <const Fields extends Schema.Struct.Fields>(fields: Fields) => PreserveIdMetadata<Schema.Struct<Fields>, Fields[keyof Fields]>;
+declare const optional: <Value extends Schema.Constraint>(value: Value) => PreserveIdMetadata<Schema.optional<Value>, Value>;
+declare const nullable: <Value extends Schema.Constraint>(value: Value) => PreserveIdMetadata<Schema.NullOr<Value>, Value>;
+declare const record: <Value extends Schema.Constraint>(value: Value) => PreserveIdMetadata<Schema.$Record<Schema.String, Value>, Value>;
+declare const union: <const Members extends ReadonlyArray<Schema.Constraint>>(...members: Members) => PreserveIdMetadata<Schema.Union<Members>, Members[number]>;
+declare const error: <const Tag extends string, const Fields extends Schema.Struct.Fields>(tag: Tag & ErrorTagValidation<Tag>, fields: Fields & ReservedErrorFieldValidation<NoInfer<Fields>>) => ErrorDefinition<Tag, Fields>;
+declare const values: {
+  array: typeof array;
+  boolean: typeof boolean;
+  date: typeof date;
+  error: typeof error;
+  id: typeof id;
+  integer: typeof integer;
+  literal: typeof literal;
+  literals: typeof literals;
+  never: typeof never;
+  null: typeof nullValue;
+  nullable: typeof nullable;
+  number: typeof number;
+  object: typeof object;
+  optional: typeof optional;
+  record: typeof record;
+  string: typeof string;
+  union: typeof union;
+};
+type BoundValues<TableName extends string> = Omit<typeof values, "id"> & {
+  readonly id: <const Target extends TableName>(tableName: Target) => IdDefinition<Target>;
+};
+//#endregion
+//#region ../contracts/dist/schema/index.d.ts
+//#region src/schema/definition.d.ts
+type AnyTableDefinition = TableDefinition<Schema.Struct.Fields>;
+interface Tables {
+  readonly [tableName: string]: AnyTableDefinition;
+}
+type FieldsOf<Table extends AnyTableDefinition> = Table["fields"];
+type IdTargetsOfFields<Fields extends Schema.Struct.Fields> = { readonly [FieldName in keyof Fields]: IdTargetsOf<Fields[FieldName]>; }[keyof Fields];
+declare const UnknownTableReferenceTypeId: unique symbol;
+interface UnknownTableReference<TableName extends string> {
+  readonly [UnknownTableReferenceTypeId]: `Unknown table reference: ${TableName}`;
+}
+type DefinitionReferenceValidation<Definitions extends Tables> = { readonly [TableName in keyof Definitions]: Exclude<IdTargetsOfFields<FieldsOf<Definitions[TableName]>>, keyof Definitions & string> extends (infer UnknownTarget extends string) ? [UnknownTarget] extends [never] ? unknown : UnknownTableReference<UnknownTarget> : never; };
+type TableNameOf<SchemaDefinition extends Tables> = keyof SchemaDefinition & string;
+interface DefinedSchema<SchemaDefinition extends Tables> extends SchemaDefinitionContract<SchemaDefinition> {
+  readonly _tag: "Schema";
+}
+interface SchemaAuthoring {
+  readonly table: typeof table;
+  readonly values: typeof values;
+}
+declare const defineSchema: <const Definitions extends Tables>(define: (authoring: SchemaAuthoring) => Definitions & DefinitionReferenceValidation<NoInfer<Definitions>>) => DefinedSchema<Definitions>;
+//#endregion
+//#region src/schema/server.d.ts
+type TransportSchema = Schema.ConstraintCodec<unknown, unknown, never, never>;
+interface ErrorSchema extends Schema.ConstraintCodec<ErrorValue, unknown, never, never> {
+  readonly Type: ErrorValue;
+}
+interface ResolvedFunctionValue {
+  readonly [UnresolvedReferencesTypeId]?: never;
+}
+type ResolvedFunctionFields<Fields extends Schema.Struct.Fields> = { readonly [FieldName in keyof Fields]: Fields[FieldName] & ResolvedFunctionValue & TransportSchema; };
+interface ForbiddenSystemFields {
+  readonly id?: never;
+  readonly createdAt?: never;
+  readonly updatedAt?: never;
+}
+type InsertOf<Table extends Tables[string]> = Schema.Struct.MakeIn<FieldsOf<Table>> & ForbiddenSystemFields;
+type PatchOf<Table extends Tables[string]> = Partial<Schema.Struct.MakeIn<FieldsOf<Table>>> & ForbiddenSystemFields;
+type FunctionArgs = Schema.Struct.Fields | undefined;
+type FunctionReturns = TransportSchema | undefined;
+type ArgsOf<Args extends FunctionArgs> = Args extends Schema.Struct.Fields ? keyof Args extends never ? void : Schema.Struct.Type<Args> : void;
+type ReturnOf<Returns extends FunctionReturns> = Returns extends TransportSchema ? Returns["Type"] : void;
+type DocumentNotFound<TableName extends string = string> = DocumentNotFoundValue<TableName, Id<TableName>>;
+interface DatabaseQuery<Definition extends Tables, Name extends TableNameOf<Definition>> {
+  collect(): Result<ReadonlyArray<Document<Definition, Name>>, never>;
+}
+interface DatabaseReader<Definition extends Tables> {
+  query<const Name extends TableNameOf<Definition>>(name: Name): DatabaseQuery<Definition, Name>;
+  find<const Name extends TableNameOf<Definition>>(name: Name, id: Id<NoInfer<Name>>): Result<Document<Definition, Name> | undefined, never>;
+  get<const Name extends TableNameOf<Definition>>(name: Name, id: Id<NoInfer<Name>>): Result<Document<Definition, Name>, DocumentNotFound<Name>>;
+}
+interface DatabaseWriter<Definition extends Tables> extends DatabaseReader<Definition> {
+  delete<const Name extends TableNameOf<Definition>>(name: Name, id: Id<NoInfer<Name>>): Result<void, never>;
+  insert<const Name extends TableNameOf<Definition>>(name: Name, value: InsertOf<Definition[NoInfer<Name>]>): Result<Id<Name>, never>;
+  patch<const Name extends TableNameOf<Definition>>(name: Name, id: Id<NoInfer<Name>>, value: PatchOf<Definition[NoInfer<Name>]>): Result<void, never>;
+  replace<const Name extends TableNameOf<Definition>>(name: Name, id: Id<NoInfer<Name>>, value: InsertOf<Definition[NoInfer<Name>]>): Result<void, never>;
+}
+interface QueryContext<Definition extends Tables> {
+  readonly db: DatabaseReader<Definition>;
+}
+interface MutationContext<Definition extends Tables> {
+  readonly db: DatabaseWriter<Definition>;
+}
+type FunctionKind = "Mutation" | "Query";
+type HandlerContext<Kind extends FunctionKind, Definition extends Tables> = Kind extends "Query" ? QueryContext<Definition> : MutationContext<Definition>;
+type Handler<Kind extends FunctionKind, Definition extends Tables, Args extends FunctionArgs, Success, Failure extends ErrorValue> = (ctx: HandlerContext<Kind, Definition>, args: ArgsOf<Args>) => Generator<Effect.Effect<unknown, Failure, never>, Success, never>;
+type HandlerFailure<HandlerType> = HandlerType extends ((...arguments_: infer _Arguments) => Generator<infer Yielded, unknown, never>) ? Yielded extends Effect.Effect<unknown, infer Failure extends ErrorValue, never> ? Failure : never : never;
+type FunctionDefinition<Kind extends FunctionKind, Definition extends Tables, Args extends FunctionArgs, Returns extends FunctionReturns, Errors extends ErrorSchema | undefined, Failure extends ErrorValue> = {
+  readonly _tag: Kind;
+  readonly handler: Handler<Kind, Definition, Args, ReturnOf<Returns>, Failure>;
+} & (Args extends Schema.Struct.Fields ? {
+  readonly args: Args;
+} : {
+  readonly args?: never;
+}) & (Returns extends TransportSchema ? {
+  readonly returns: Returns;
+} : {
+  readonly returns?: never;
+}) & (Errors extends ErrorSchema ? {
+  readonly errors: Errors;
+} : {
+  readonly errors?: never;
+});
+interface FunctionInput<Kind extends FunctionKind, Definition extends Tables, Args extends FunctionArgs, Success, Failure extends ErrorValue> {
+  readonly handler: Handler<Kind, Definition, Args, Success, Failure>;
+}
+type WithArgs<Args extends Schema.Struct.Fields> = {
+  readonly args: Args & ResolvedFunctionFields<NoInfer<Args>>;
+};
+interface WithoutArgs {
+  readonly args?: never;
+}
+type WithReturns<Returns extends TransportSchema> = {
+  readonly returns: Returns & ResolvedFunctionValue;
+};
+interface WithoutReturns {
+  readonly returns?: never;
+}
+interface DefineFunction<Kind extends FunctionKind, Definition extends Tables> {
+  <const Args extends Schema.Struct.Fields, Returns extends TransportSchema, Errors extends ErrorSchema>(definition: FunctionInput<Kind, Definition, Args, Returns["Type"], Errors["Type"]> & WithArgs<Args> & WithReturns<Returns> & {
+    readonly errors: Errors & ResolvedFunctionValue;
+  }): FunctionDefinition<Kind, Definition, Args, Returns, Errors, Errors["Type"]>;
+  <Returns extends TransportSchema, Errors extends ErrorSchema>(definition: FunctionInput<Kind, Definition, undefined, Returns["Type"], Errors["Type"]> & WithoutArgs & WithReturns<Returns> & {
+    readonly errors: Errors & ResolvedFunctionValue;
+  }): FunctionDefinition<Kind, Definition, undefined, Returns, Errors, Errors["Type"]>;
+  <const Args extends Schema.Struct.Fields, Errors extends ErrorSchema>(definition: FunctionInput<Kind, Definition, Args, void, Errors["Type"]> & WithArgs<Args> & WithoutReturns & {
+    readonly errors: Errors & ResolvedFunctionValue;
+  }): FunctionDefinition<Kind, Definition, Args, undefined, Errors, Errors["Type"]>;
+  <Errors extends ErrorSchema>(definition: FunctionInput<Kind, Definition, undefined, void, Errors["Type"]> & WithoutArgs & WithoutReturns & {
+    readonly errors: Errors & ResolvedFunctionValue;
+  }): FunctionDefinition<Kind, Definition, undefined, undefined, Errors, Errors["Type"]>;
+  <const Args extends Schema.Struct.Fields, Returns extends TransportSchema, HandlerType extends Handler<Kind, Definition, Args, Returns["Type"], ErrorValue> = Handler<Kind, Definition, Args, Returns["Type"], never>>(definition: WithArgs<Args> & WithReturns<Returns> & {
+    readonly errors?: never;
+    readonly handler: HandlerType;
+  }): FunctionDefinition<Kind, Definition, Args, Returns, undefined, HandlerFailure<HandlerType>>;
+  <Returns extends TransportSchema, HandlerType extends Handler<Kind, Definition, undefined, Returns["Type"], ErrorValue> = Handler<Kind, Definition, undefined, Returns["Type"], never>>(definition: WithoutArgs & WithReturns<Returns> & {
+    readonly errors?: never;
+    readonly handler: HandlerType;
+  }): FunctionDefinition<Kind, Definition, undefined, Returns, undefined, HandlerFailure<HandlerType>>;
+  <const Args extends Schema.Struct.Fields, HandlerType extends Handler<Kind, Definition, Args, void, ErrorValue> = Handler<Kind, Definition, Args, void, never>>(definition: WithArgs<Args> & WithoutReturns & {
+    readonly errors?: never;
+    readonly handler: HandlerType;
+  }): FunctionDefinition<Kind, Definition, Args, undefined, undefined, HandlerFailure<HandlerType>>;
+  <HandlerType extends Handler<Kind, Definition, undefined, void, ErrorValue> = Handler<Kind, Definition, undefined, void, never>>(definition: WithoutArgs & WithoutReturns & {
+    readonly errors?: never;
+    readonly handler: HandlerType;
+  }): FunctionDefinition<Kind, Definition, undefined, undefined, undefined, HandlerFailure<HandlerType>>;
+}
+interface FunctionBuilders<Definition extends Tables> {
+  readonly query: DefineFunction<"Query", Definition>;
+  readonly mutation: DefineFunction<"Mutation", Definition>;
+}
+interface SchemaBindings<Definition extends Tables> extends FunctionBuilders<Definition> {
+  readonly values: BoundValues<TableNameOf<Definition>>;
+}
+declare const bindSchema: <const Definition extends Tables>(schema: DefinedSchema<Definition>) => SchemaBindings<Definition>;
+//#endregion
+export { Document as a, SchemaDefinitionTypeId as c, defineSchema as i, SchemaAuthoring as n, Id as o, bindSchema as r, SchemaDefinitionOf as s, DefinedSchema as t };
+//# sourceMappingURL=index-BgWROoyk.d.ts.map

package/dist/runtime/internal/api.d.ts

@@ -0,0 +1,2 @@
+import { i as functionPathOf, n as FunctionReference, r as createApi, t as Api } from "../api-Cpx57mk3.js";
+export { Api, FunctionReference, createApi, functionPathOf };

package/dist/runtime/internal/api.js

@@ -0,0 +1,2 @@
+import { n as functionPathOf, t as createApi } from "../api-BXXIZc_Q.js";
+export { createApi, functionPathOf };

package/dist/runtime/internal/server.d.ts

@@ -0,0 +1,6 @@
+import { r as bindSchema$1 } from "../index-BgWROoyk.js";
+//#region src/internal/server.d.ts
+declare const bindSchema: typeof bindSchema$1;
+//#endregion
+export { bindSchema };
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/internal/server.js

@@ -0,0 +1,7 @@
+import { n as bindSchema$1 } from "../schema-CNEVLF7D.js";
+//#region src/internal/server.ts
+const bindSchema = bindSchema$1;
+//#endregion
+export { bindSchema };
+
+//# sourceMappingURL=server.js.map

package/dist/runtime/internal/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":["bindContractSchema"],"sources":["../../../src/internal/server.ts"],"sourcesContent":["import { bindSchema as bindContractSchema } from \"@ignotum/contracts/schema\";\n\nexport const bindSchema: typeof bindContractSchema = bindContractSchema;\n"],"mappings":";;AAEA,MAAa,aAAwCA"}

package/dist/runtime/internal/types.d.ts

@@ -0,0 +1,2 @@
+import { a as Document, c as SchemaDefinitionTypeId, o as Id, s as SchemaDefinitionOf } from "../index-BgWROoyk.js";
+export { type Document, type Id, type SchemaDefinitionOf, SchemaDefinitionTypeId };

package/dist/runtime/internal/types.js

@@ -0,0 +1,2 @@
+import { t as SchemaDefinitionTypeId } from "../schema-CNEVLF7D.js";
+export { SchemaDefinitionTypeId };

package/dist/runtime/result-B2W-z2wG.js

@@ -0,0 +1,136 @@
+import { Brand, Effect, Effectable, Function, Option, Predicate, Schema } from "effect";
+//#region ../contracts/dist/value-Briqf-Ua.js
+const TransportValueSchema = Schema.suspend(() => Schema.Union([
+	Schema.Null,
+	Schema.Boolean,
+	Schema.Finite,
+	Schema.String,
+	Schema.Date,
+	Schema.Array(TransportValueSchema),
+	Schema.Record(Schema.String, Schema.UndefinedOr(TransportValueSchema))
+]));
+const encodeTransportValue = (value) => {
+	if (Predicate.isDate(value)) return Schema.encodeSync(Schema.DateFromMillis)(value);
+	if (globalThis.Array.isArray(value)) return value.map(encodeTransportValue);
+	if (Predicate.isNumber(value)) return Schema.decodeSync(Schema.Finite)(value);
+	if (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isBoolean(value)) return value;
+	return Object.fromEntries(Object.entries(value).flatMap(([key, child]) => child === void 0 ? [] : [[key, encodeTransportValue(child)]]));
+};
+const encodeTransportObject = (value) => Schema.decodeUnknownSync(Schema.JsonObject)(encodeTransportValue(Schema.decodeUnknownSync(TransportValueSchema)(value)));
+const pathKey = (path) => JSON.stringify(path);
+const decodeTransportValueAt = (value, path, encodedDatePaths) => {
+	if (encodedDatePaths.has(pathKey(path))) return Schema.decodeUnknownSync(Schema.DateFromMillis)(value);
+	if (globalThis.Array.isArray(value)) return value.map((item, index) => decodeTransportValueAt(item, [...path, index], encodedDatePaths));
+	if (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, decodeTransportValueAt(item, [...path, key], encodedDatePaths)]));
+};
+const decodeTransportValue = (value, datePaths) => decodeTransportValueAt(value, [], new Set(datePaths.map(pathKey)));
+const decodeTransportObject = (value, datePaths) => {
+	const encodedDatePaths = new Set(datePaths.map(pathKey));
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeTransportValueAt(child, [key], encodedDatePaths)]));
+};
+//#endregion
+//#region ../contracts/dist/runtime/result.js
+const ResultTypeId = Symbol.for("ignotum/runtime/result/Result");
+const CompletedResultTypeId = Symbol.for("ignotum/runtime/result/Completed");
+const PendingResultTypeId = Symbol.for("ignotum/runtime/result/Pending");
+const ErrorBrand = "ignotum/error";
+const makeErrorValue = Brand.nominal();
+const ErrorValueSchema = Schema.StructWithRest(Schema.Struct({ _tag: Schema.String }), [Schema.Record(Schema.String, Schema.Json)]).pipe(Schema.brand(ErrorBrand));
+var InternalServerErrorCause = class extends Schema.TaggedError()("InternalServerError", { requestId: Schema.String }) {};
+const InternalServerErrorSchema = InternalServerErrorCause.pipe(Schema.brand(ErrorBrand));
+const effectOf = (value) => Predicate.hasProperty(value, ResultTypeId) ? value[ResultTypeId] : Effect.succeed(value);
+function makeResultEffectBase() {
+	const Base = function() {};
+	Base.prototype = Effectable.Prototype({
+		label: "IgnotumResult",
+		evaluate() {
+			return this[ResultTypeId];
+		}
+	});
+	return Base;
+}
+const ResultEffectBase = makeResultEffectBase();
+var ResultOperation = class ResultOperation extends ResultEffectBase {
+	[ResultTypeId];
+	constructor(effect, completed) {
+		super();
+		this[ResultTypeId] = effect;
+		if (completed !== void 0) Object.defineProperty(this, CompletedResultTypeId, { value: completed });
+	}
+	catch(cases) {
+		const effectCases = {};
+		for (const [tag, handler] of Object.entries(cases)) if (Predicate.isFunction(handler)) effectCases[tag] = (failure) => effectOf(handler(failure));
+		const runtimeEffect = this[ResultTypeId];
+		const caught = Effect.catchTags(runtimeEffect, effectCases);
+		return new ResultOperation(caught);
+	}
+};
+var PendingQueryResult = class {
+	[PendingResultTypeId] = PendingResultTypeId;
+};
+const inspectResult = (value) => {
+	if (!Predicate.hasProperty(value, CompletedResultTypeId)) return void 0;
+	return value[CompletedResultTypeId];
+};
+const isFailureResult = (result) => Predicate.hasProperty(result, CompletedResultTypeId) && Predicate.isObject(result[CompletedResultTypeId]) && Predicate.hasProperty(result[CompletedResultTypeId], "type") && result[CompletedResultTypeId].type === "Failure";
+const succeed = (value) => new ResultOperation(Effect.succeed(value), {
+	type: "Success",
+	value
+});
+const fail = (error) => new ResultOperation(Effect.fail(error), {
+	type: "Failure",
+	error
+});
+const tryResult = (body) => {
+	return new ResultOperation(Effect.gen(body));
+};
+const match = Function.dual(2, (result, matchers) => {
+	if (result instanceof PendingQueryResult) {
+		if (matchers.pending === void 0) throw new Error("A pending Result requires a pending matcher.");
+		return matchers.pending();
+	}
+	if (!Predicate.hasProperty(result, ResultTypeId)) throw new Error("Unknown Result implementation.");
+	const inspected = inspectResult(result);
+	if (inspected?.type === "Success") {
+		const value = inspected.value;
+		return matchers.value(value);
+	}
+	if (!isFailureResult(result)) throw new Error("Unknown or incomplete Result operation.");
+	const error = result[CompletedResultTypeId].error;
+	if (error._tag === "InternalServerError") {
+		const internalError = Schema.decodeUnknownSync(InternalServerErrorSchema)(error);
+		const handler = matchers.internalError;
+		if (handler === void 0) throw internalError;
+		return handler(internalError);
+	}
+	const errorMatcher = matchers.error;
+	if (errorMatcher === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);
+	if (Predicate.isFunction(errorMatcher)) return errorMatcher(error);
+	const handlers = errorMatcher;
+	const handler = Object.hasOwn(handlers, error._tag) ? handlers[error._tag] : void 0;
+	if (handler === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);
+	return handler(error);
+});
+const pending = () => new PendingQueryResult();
+const failureFromWire = (error, datePaths = []) => {
+	const internalError = Schema.decodeUnknownOption(InternalServerErrorSchema)(error);
+	if (Option.isSome(internalError)) return fail(internalError.value);
+	const decoded = Schema.decodeUnknownOption(ErrorValueSchema)(error);
+	if (Option.isNone(decoded)) throw new Error("The server returned an invalid application error.");
+	const restored = decodeTransportObject(decoded.value, datePaths);
+	return fail(makeErrorValue({
+		...restored,
+		_tag: decoded.value._tag
+	}));
+};
+const Result = {
+	fail,
+	match,
+	succeed,
+	try: tryResult
+};
+//#endregion
+export { decodeTransportValue as a, pending as i, Result as n, encodeTransportObject as o, failureFromWire as r, ErrorBrand as t };
+
+//# sourceMappingURL=result-B2W-z2wG.js.map

package/dist/runtime/result-B2W-z2wG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-B2W-z2wG.js","names":[],"sources":["../../../contracts/dist/value-Briqf-Ua.js","../../../contracts/dist/runtime/result.js"],"sourcesContent":["import { Predicate, Schema } from \"effect\";\n//#region src/runtime/value.ts\nconst TransportValueSchema = Schema.suspend(() => Schema.Union([\n\tSchema.Null,\n\tSchema.Boolean,\n\tSchema.Finite,\n\tSchema.String,\n\tSchema.Date,\n\tSchema.Array(TransportValueSchema),\n\tSchema.Record(Schema.String, Schema.UndefinedOr(TransportValueSchema))\n]));\nconst encodeTransportValue = (value) => {\n\tif (Predicate.isDate(value)) return Schema.encodeSync(Schema.DateFromMillis)(value);\n\tif (globalThis.Array.isArray(value)) return value.map(encodeTransportValue);\n\tif (Predicate.isNumber(value)) return Schema.decodeSync(Schema.Finite)(value);\n\tif (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isBoolean(value)) return value;\n\treturn Object.fromEntries(Object.entries(value).flatMap(([key, child]) => child === void 0 ? [] : [[key, encodeTransportValue(child)]]));\n};\nconst encodeTransportObject = (value) => Schema.decodeUnknownSync(Schema.JsonObject)(encodeTransportValue(Schema.decodeUnknownSync(TransportValueSchema)(value)));\nconst collectDatePaths = (value, path, paths) => {\n\tif (Predicate.isDate(value)) {\n\t\tSchema.decodeSync(Schema.Date)(value);\n\t\tpaths.push(path);\n\t\treturn;\n\t}\n\tif (globalThis.Array.isArray(value)) {\n\t\tfor (const [index, child] of value.entries()) collectDatePaths(child, [...path, index], paths);\n\t\treturn;\n\t}\n\tif (value === void 0 || Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return;\n\tfor (const [key, child] of Object.entries(value)) collectDatePaths(child, [...path, key], paths);\n};\nconst datePathsOf = (value) => {\n\tconst paths = [];\n\tcollectDatePaths(value, [], paths);\n\treturn paths;\n};\nconst datePathsOfObject = (value) => datePathsOf(Schema.decodeUnknownSync(TransportValueSchema)(value));\nconst pathKey = (path) => JSON.stringify(path);\nconst decodeTransportValueAt = (value, path, encodedDatePaths) => {\n\tif (encodedDatePaths.has(pathKey(path))) return Schema.decodeUnknownSync(Schema.DateFromMillis)(value);\n\tif (globalThis.Array.isArray(value)) return value.map((item, index) => decodeTransportValueAt(item, [...path, index], encodedDatePaths));\n\tif (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return value;\n\treturn Object.fromEntries(Object.entries(value).map(([key, item]) => [key, decodeTransportValueAt(item, [...path, key], encodedDatePaths)]));\n};\nconst decodeTransportValue = (value, datePaths) => decodeTransportValueAt(value, [], new Set(datePaths.map(pathKey)));\nconst decodeTransportObject = (value, datePaths) => {\n\tconst encodedDatePaths = new Set(datePaths.map(pathKey));\n\treturn Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeTransportValueAt(child, [key], encodedDatePaths)]));\n};\n//#endregion\nexport { decodeTransportValue as a, decodeTransportObject as i, datePathsOf as n, encodeTransportObject as o, datePathsOfObject as r, encodeTransportValue as s, TransportValueSchema as t };\n\n//# sourceMappingURL=value-Briqf-Ua.js.map","import { i as decodeTransportObject } from \"../value-Briqf-Ua.js\";\nimport { Brand, Effect, Effectable, Function, Option, Predicate, Schema } from \"effect\";\n//#region src/runtime/result.ts\nconst ResultTypeId = Symbol.for(\"ignotum/runtime/result/Result\");\nconst CompletedResultTypeId = Symbol.for(\"ignotum/runtime/result/Completed\");\nconst PendingResultTypeId = Symbol.for(\"ignotum/runtime/result/Pending\");\nconst ErrorBrand = \"ignotum/error\";\nconst makeErrorValue = Brand.nominal();\nconst ErrorValueSchema = Schema.StructWithRest(Schema.Struct({ _tag: Schema.String }), [Schema.Record(Schema.String, Schema.Json)]).pipe(Schema.brand(ErrorBrand));\nvar InternalServerErrorCause = class extends Schema.TaggedError()(\"InternalServerError\", { requestId: Schema.String }) {};\nconst InternalServerError = InternalServerErrorCause;\nconst InternalServerErrorSchema = InternalServerErrorCause.pipe(Schema.brand(ErrorBrand));\nconst effectOf = (value) => Predicate.hasProperty(value, ResultTypeId) ? value[ResultTypeId] : Effect.succeed(value);\nfunction makeResultEffectBase() {\n\tconst Base = function() {};\n\tBase.prototype = Effectable.Prototype({\n\t\tlabel: \"IgnotumResult\",\n\t\tevaluate() {\n\t\t\treturn this[ResultTypeId];\n\t\t}\n\t});\n\treturn Base;\n}\nconst ResultEffectBase = makeResultEffectBase();\nvar ResultOperation = class ResultOperation extends ResultEffectBase {\n\t[ResultTypeId];\n\tconstructor(effect, completed) {\n\t\tsuper();\n\t\tthis[ResultTypeId] = effect;\n\t\tif (completed !== void 0) Object.defineProperty(this, CompletedResultTypeId, { value: completed });\n\t}\n\tcatch(cases) {\n\t\tconst effectCases = {};\n\t\tfor (const [tag, handler] of Object.entries(cases)) if (Predicate.isFunction(handler)) effectCases[tag] = (failure) => effectOf(handler(failure));\n\t\tconst runtimeEffect = this[ResultTypeId];\n\t\tconst caught = Effect.catchTags(runtimeEffect, effectCases);\n\t\treturn new ResultOperation(caught);\n\t}\n};\nvar PendingQueryResult = class {\n\t[PendingResultTypeId] = PendingResultTypeId;\n};\nconst inspectResult = (value) => {\n\tif (!Predicate.hasProperty(value, CompletedResultTypeId)) return void 0;\n\treturn value[CompletedResultTypeId];\n};\nconst effectFromResult = (result) => result[ResultTypeId];\nconst resultFromEffect = (effect) => new ResultOperation(effect);\nconst isFailureResult = (result) => Predicate.hasProperty(result, CompletedResultTypeId) && Predicate.isObject(result[CompletedResultTypeId]) && Predicate.hasProperty(result[CompletedResultTypeId], \"type\") && result[CompletedResultTypeId].type === \"Failure\";\nconst succeed = (value) => new ResultOperation(Effect.succeed(value), {\n\ttype: \"Success\",\n\tvalue\n});\nconst fail = (error) => new ResultOperation(Effect.fail(error), {\n\ttype: \"Failure\",\n\terror\n});\nconst tryResult = (body) => {\n\treturn new ResultOperation(Effect.gen(body));\n};\nconst match = Function.dual(2, (result, matchers) => {\n\tif (result instanceof PendingQueryResult) {\n\t\tif (matchers.pending === void 0) throw new Error(\"A pending Result requires a pending matcher.\");\n\t\treturn matchers.pending();\n\t}\n\tif (!Predicate.hasProperty(result, ResultTypeId)) throw new Error(\"Unknown Result implementation.\");\n\tconst inspected = inspectResult(result);\n\tif (inspected?.type === \"Success\") {\n\t\tconst value = inspected.value;\n\t\treturn matchers.value(value);\n\t}\n\tif (!isFailureResult(result)) throw new Error(\"Unknown or incomplete Result operation.\");\n\tconst error = result[CompletedResultTypeId].error;\n\tif (error._tag === \"InternalServerError\") {\n\t\tconst internalError = Schema.decodeUnknownSync(InternalServerErrorSchema)(error);\n\t\tconst handler = matchers.internalError;\n\t\tif (handler === void 0) throw internalError;\n\t\treturn handler(internalError);\n\t}\n\tconst errorMatcher = matchers.error;\n\tif (errorMatcher === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);\n\tif (Predicate.isFunction(errorMatcher)) return errorMatcher(error);\n\tconst handlers = errorMatcher;\n\tconst handler = Object.hasOwn(handlers, error._tag) ? handlers[error._tag] : void 0;\n\tif (handler === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);\n\treturn handler(error);\n});\nconst pending = () => new PendingQueryResult();\nconst failureFromWire = (error, datePaths = []) => {\n\tconst internalError = Schema.decodeUnknownOption(InternalServerErrorSchema)(error);\n\tif (Option.isSome(internalError)) return fail(internalError.value);\n\tconst decoded = Schema.decodeUnknownOption(ErrorValueSchema)(error);\n\tif (Option.isNone(decoded)) throw new Error(\"The server returned an invalid application error.\");\n\tconst restored = decodeTransportObject(decoded.value, datePaths);\n\treturn fail(makeErrorValue({\n\t\t...restored,\n\t\t_tag: decoded.value._tag\n\t}));\n};\nconst documentNotFound = (table, id) => Brand.nominal()({\n\t_tag: \"DocumentNotFound\",\n\ttable,\n\tid\n});\nconst Result = {\n\tfail,\n\tmatch,\n\tsucceed,\n\ttry: tryResult\n};\n//#endregion\nexport { ErrorBrand, ErrorValueSchema, InternalServerError, InternalServerErrorSchema, Result, documentNotFound, effectFromResult, failureFromWire, inspectResult, match, pending, resultFromEffect };\n\n//# sourceMappingURL=result.js.map"],"mappings":"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"}

package/dist/runtime/result-C1ZdsM6Y.d.ts

@@ -0,0 +1,106 @@
+import { Brand, Effect, Schema } from "effect";
+//#region ../contracts/dist/runtime/result.d.ts
+//#region src/runtime/result.d.ts
+declare const ResultTypeId: unique symbol;
+declare const PendingResultTypeId: unique symbol;
+declare const ErrorBrand: "ignotum/error";
+type ErrorValue = {
+  readonly _tag: string;
+} & Brand.Brand<typeof ErrorBrand>;
+declare const InternalServerErrorCause_base: Schema.Class<InternalServerErrorCause, Schema.TaggedStruct<"InternalServerError", {
+  readonly requestId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InternalServerErrorCause extends InternalServerErrorCause_base {}
+declare const InternalServerError: typeof InternalServerErrorCause;
+declare const InternalServerErrorSchema: Schema.brand<Schema.decodeTo<Schema.declareConstructor<InternalServerErrorCause, {
+  readonly _tag: "InternalServerError";
+  readonly requestId: string;
+}, readonly [Schema.TaggedStruct<"InternalServerError", {
+  readonly requestId: Schema.String;
+}>], {
+  readonly _tag: "InternalServerError";
+  readonly requestId: string;
+}>, Schema.TaggedStruct<"InternalServerError", {
+  readonly requestId: Schema.String;
+}>, never, never>, "ignotum/error">;
+type InternalServerError = typeof InternalServerErrorSchema.Type;
+type DocumentNotFoundValue<TableName extends string = string, Identifier extends string = string> = ErrorValue & {
+  readonly _tag: "DocumentNotFound";
+  readonly table: TableName;
+  readonly id: Identifier;
+};
+type CatchOutput = object | string | number | boolean | bigint | symbol | null | undefined;
+type CatchCases<Failure extends ErrorValue> = { readonly [Tag in Failure["_tag"]]?: (failure: Extract<Failure, {
+  readonly _tag: Tag;
+}>) => CatchOutput; };
+type CaseReturn<Cases> = ReturnType<Extract<Cases[keyof Cases], (...args: never) => CatchOutput>>;
+type SuccessOfReturn<Value> = Value extends Result<infer Success, ErrorValue> ? Success : Value;
+type FailureOfReturn<Value> = Value extends Result<unknown, infer Failure> ? Failure : never;
+type HandledTags<Cases> = Extract<keyof Cases, string>;
+type YieldFailure<Yielded> = Yielded extends Effect.Effect<unknown, infer Failure, never> ? Failure extends ErrorValue ? Failure : never : never;
+interface Result<out Success, out Failure extends ErrorValue> {
+  readonly [ResultTypeId]: Effect.Effect<Success, Failure>;
+  [Symbol.iterator](): Effect.EffectIterator<Effect.Effect<Success, Failure>>;
+  catch<const Cases extends CatchCases<Failure>>(cases: Cases & { readonly [Tag in Exclude<keyof Cases, Failure["_tag"]>]: never; }): Result<Success | SuccessOfReturn<CaseReturn<Cases>>, Exclude<Failure, {
+    readonly _tag: HandledTags<Cases>;
+  }> | FailureOfReturn<CaseReturn<Cases>>>;
+}
+type SettledResult<Success, Failure extends ErrorValue> = Omit<Result<Success, Failure>, "catch" | typeof Symbol.iterator>;
+interface PendingResult {
+  readonly [PendingResultTypeId]: typeof PendingResultTypeId;
+}
+type QueryResult<Success, Failure extends ErrorValue> = PendingResult | SettledResult<Success, Failure>;
+type ApplicationError<Failure extends ErrorValue> = Exclude<Failure, {
+  readonly _tag: "InternalServerError";
+}>;
+type InternalError<Failure extends ErrorValue> = Extract<Failure, {
+  readonly _tag: "InternalServerError";
+}>;
+type ErrorHandlers<Failure extends ErrorValue, Output> = { readonly [Tag in Failure["_tag"]]: (error: Extract<Failure, {
+  readonly _tag: Tag;
+}>) => Output; };
+type ErrorMatcher<Failure extends ErrorValue, Output> = [ApplicationError<Failure>] extends [never] ? {
+  readonly error?: never;
+} : {
+  readonly error: ((error: ApplicationError<Failure>) => Output) | ErrorHandlers<ApplicationError<Failure>, Output>;
+};
+type InternalErrorMatcher<Failure extends ErrorValue, Output> = [InternalError<Failure>] extends [never] ? {
+  readonly internalError?: never;
+} : {
+  readonly internalError?: (error: InternalError<Failure>) => Output;
+};
+type ResultMatchers<Success, Failure extends ErrorValue, Output> = {
+  readonly value: (value: Success) => Output;
+} & ErrorMatcher<Failure, Output> & InternalErrorMatcher<Failure, Output>;
+type QueryResultMatchers<Success, Failure extends ErrorValue, Output> = {
+  readonly pending: () => Output;
+  readonly value: (value: Success) => Output;
+} & ErrorMatcher<Failure, Output> & InternalErrorMatcher<Failure, Output>;
+type CurriedResultMatchers<Success, Failure extends ErrorValue, Output> = Omit<ResultMatchers<Success, Failure, Output>, "internalError"> & ([InternalError<Failure>] extends [never] ? {
+  readonly internalError?: never;
+} : {
+  readonly internalError?: (error: InternalError<NoInfer<Failure>>) => Output;
+});
+type CurriedQueryResultMatchers<Success, Failure extends ErrorValue, Output> = Omit<QueryResultMatchers<Success, Failure, Output>, "internalError"> & ([InternalError<Failure>] extends [never] ? {
+  readonly internalError?: never;
+} : {
+  readonly internalError?: (error: InternalError<NoInfer<Failure>>) => Output;
+});
+declare const succeed: <Actual, Expected = Actual>(value: Actual & NoInfer<Expected>) => Result<Expected, never>;
+declare const fail: <Actual extends ErrorValue, Expected extends ErrorValue = Actual>(error: Actual & NoInfer<Expected>) => Result<never, Expected>;
+declare const tryResult: <Success, Yielded extends Effect.Effect<unknown, ErrorValue, never>>(body: () => Generator<Yielded, Success, never>) => Result<Success, [Yielded] extends [never] ? never : YieldFailure<Yielded>>;
+interface Match {
+  <Success, Failure extends ErrorValue, Output>(result: SettledResult<Success, Failure>, matchers: ResultMatchers<Success, Failure, Output>): Output;
+  <Success, Failure extends ErrorValue, Output>(result: QueryResult<Success, Failure>, matchers: QueryResultMatchers<Success, Failure, Output>): Output;
+  <Success, Failure extends ErrorValue, Output>(matchers: CurriedQueryResultMatchers<Success, Failure, Output>): (result: QueryResult<Success, Failure>) => Output;
+  <Success, Failure extends ErrorValue, Output>(matchers: CurriedResultMatchers<Success, Failure, Output>): (result: SettledResult<Success, Failure>) => Output;
+}
+declare const Result: {
+  fail: typeof fail;
+  match: Match;
+  succeed: typeof succeed;
+  try: typeof tryResult;
+};
+//#endregion
+export { Match as a, SettledResult as c, InternalServerError as i, ErrorBrand as n, QueryResult as o, ErrorValue as r, Result as s, DocumentNotFoundValue as t };
+//# sourceMappingURL=result-C1ZdsM6Y.d.ts.map