kizlo 0.1.0

package/dist/shared/error.d.ts

@@ -0,0 +1,128 @@
+import { AnySchema, LiteralUnion, Metadata, SchemaInput, SchemaOutput } from "@kizlo/shared";
+
+//#region src/shared/error.d.ts
+declare const COMMON_ERRORS: {
+  BAD_REQUEST: {
+    status: number;
+    message: string;
+  };
+  UNAUTHORIZED: {
+    status: number;
+    message: string;
+  };
+  FORBIDDEN: {
+    status: number;
+    message: string;
+  };
+  NOT_FOUND: {
+    status: number;
+    message: string;
+  };
+  METHOD_NOT_SUPPORTED: {
+    status: number;
+    message: string;
+  };
+  NOT_ACCEPTABLE: {
+    status: number;
+    message: string;
+  };
+  TIMEOUT: {
+    status: number;
+    message: string;
+  };
+  CONFLICT: {
+    status: number;
+    message: string;
+  };
+  PRECONDITION_FAILED: {
+    status: number;
+    message: string;
+  };
+  PAYLOAD_TOO_LARGE: {
+    status: number;
+    message: string;
+  };
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: number;
+    message: string;
+  };
+  UNPROCESSABLE_CONTENT: {
+    status: number;
+    message: string;
+  };
+  TOO_MANY_REQUESTS: {
+    status: number;
+    message: string;
+  };
+  CLIENT_CLOSED_REQUEST: {
+    status: number;
+    message: string;
+  };
+  INTERNAL_SERVER_ERROR: {
+    status: number;
+    message: string;
+  };
+  NOT_IMPLEMENTED: {
+    status: number;
+    message: string;
+  };
+  BAD_GATEWAY: {
+    status: number;
+    message: string;
+  };
+  SERVICE_UNAVAILABLE: {
+    status: number;
+    message: string;
+  };
+  GATEWAY_TIMEOUT: {
+    status: number;
+    message: string;
+  };
+  UNEXPECTED_ERROR: {
+    status: number;
+    message: string;
+  };
+};
+type CommonErrorMap = typeof COMMON_ERRORS;
+type CommonErrorCode = keyof CommonErrorMap;
+type CommonErrorLiteral = LiteralUnion<CommonErrorCode, string>;
+type WithCommonErrorMap<TErrors extends DefinedErrorMapLike> = CommonErrorMap & { [K in keyof TErrors as string extends K ? never : K]: TErrors[K] };
+interface KizloErrorOptions {
+  message?: string;
+  status?: number;
+  data?: unknown;
+  cause?: unknown;
+}
+declare class KizloError<TCode extends CommonErrorLiteral = CommonErrorLiteral, TData = unknown> extends Error {
+  readonly name = "KizloError";
+  readonly code: TCode;
+  readonly data: TData;
+  readonly status: number;
+  constructor(code: TCode, options?: KizloErrorOptions);
+}
+declare function isKizloError(value: unknown): value is KizloError;
+declare function toKizloError(e: unknown): KizloError;
+type DefinedErrorLike = {
+  status?: number;
+  message?: string;
+  data?: AnySchema;
+};
+declare function defineErrorMap<const T extends Partial<Record<CommonErrorLiteral, DefinedErrorLike>>>(map: T): T;
+type DefinedErrorMapLike = Record<string, DefinedErrorLike>;
+type ThrowableErrorFn<TCode extends string, T extends DefinedErrorLike> = T["data"] extends AnySchema ? undefined extends SchemaInput<T["data"]> ? (options?: {
+  status?: number;
+  message?: string;
+  data?: SchemaInput<T["data"]>;
+}) => KizloError<TCode, SchemaOutput<T["data"]>> : (options: {
+  status?: number;
+  message?: string;
+  data: SchemaInput<T["data"]>;
+}) => KizloError<TCode, SchemaOutput<T["data"]>> : (options?: {
+  status?: number;
+  message?: string;
+  data?: Metadata;
+}) => KizloError<TCode, SchemaOutput<T["data"]>>;
+type ThrowableErrorMap<T extends DefinedErrorMapLike> = { [K in Extract<keyof T, string>]: ThrowableErrorFn<K, T[K]> };
+declare function createThrowableErrorMap<TError extends DefinedErrorMapLike>(errors: TError): ThrowableErrorMap<WithCommonErrorMap<TError>>;
+//#endregion
+export { COMMON_ERRORS, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, DefinedErrorLike, DefinedErrorMapLike, KizloError, KizloErrorOptions, ThrowableErrorFn, ThrowableErrorMap, WithCommonErrorMap, createThrowableErrorMap, defineErrorMap, isKizloError, toKizloError };

package/dist/shared/error.js

@@ -0,0 +1,147 @@
+//#region src/shared/error.ts
+const COMMON_ERRORS = {
+	BAD_REQUEST: {
+		status: 400,
+		message: "Bad Request"
+	},
+	UNAUTHORIZED: {
+		status: 401,
+		message: "Unauthorized"
+	},
+	FORBIDDEN: {
+		status: 403,
+		message: "Forbidden"
+	},
+	NOT_FOUND: {
+		status: 404,
+		message: "Not Found"
+	},
+	METHOD_NOT_SUPPORTED: {
+		status: 405,
+		message: "Method Not Supported"
+	},
+	NOT_ACCEPTABLE: {
+		status: 406,
+		message: "Not Acceptable"
+	},
+	TIMEOUT: {
+		status: 408,
+		message: "Request Timeout"
+	},
+	CONFLICT: {
+		status: 409,
+		message: "Conflict"
+	},
+	PRECONDITION_FAILED: {
+		status: 412,
+		message: "Precondition Failed"
+	},
+	PAYLOAD_TOO_LARGE: {
+		status: 413,
+		message: "Payload Too Large"
+	},
+	UNSUPPORTED_MEDIA_TYPE: {
+		status: 415,
+		message: "Unsupported Media Type"
+	},
+	UNPROCESSABLE_CONTENT: {
+		status: 422,
+		message: "Unprocessable Content"
+	},
+	TOO_MANY_REQUESTS: {
+		status: 429,
+		message: "Too Many Requests"
+	},
+	CLIENT_CLOSED_REQUEST: {
+		status: 499,
+		message: "Client Closed Request"
+	},
+	INTERNAL_SERVER_ERROR: {
+		status: 500,
+		message: "Internal Server Error"
+	},
+	NOT_IMPLEMENTED: {
+		status: 501,
+		message: "Not Implemented"
+	},
+	BAD_GATEWAY: {
+		status: 502,
+		message: "Bad Gateway"
+	},
+	SERVICE_UNAVAILABLE: {
+		status: 503,
+		message: "Service Unavailable"
+	},
+	GATEWAY_TIMEOUT: {
+		status: 504,
+		message: "Gateway Timeout"
+	},
+	UNEXPECTED_ERROR: {
+		status: 500,
+		message: "An unexpected error occurred"
+	}
+};
+var KizloError = class extends Error {
+	name = "KizloError";
+	code;
+	data;
+	status;
+	constructor(code, options) {
+		const preset = COMMON_ERRORS[code];
+		const message = options?.message ?? preset?.message ?? String(code);
+		super(message, options?.cause ? { cause: options.cause } : void 0);
+		this.code = code;
+		this.status = options?.status ?? preset?.status ?? 500;
+		this.data = options?.data ?? null;
+	}
+};
+function isKizloError(value) {
+	if (value instanceof KizloError) return true;
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	return v.name === "KizloError" && typeof v.code === "string" && typeof v.message === "string";
+}
+function toKizloError(e) {
+	if (isKizloError(e)) return e;
+	if (typeof e === "object" && e !== null && "code" in e && typeof e.code === "string") {
+		const err = e;
+		return new KizloError(err.code, {
+			message: err.message,
+			status: err.status,
+			data: err.data
+		});
+	}
+	return new KizloError("INTERNAL_SERVER_ERROR", {
+		message: e instanceof Error ? e.message : String(e),
+		cause: e
+	});
+}
+function defineErrorMap(map) {
+	return map;
+}
+function createThrowableErrorMap(errors) {
+	return new Proxy({}, { get(_target, p) {
+		if (typeof p === "symbol") return void 0;
+		const preset = {
+			COMMON_ERRORS,
+			...errors
+		}[p];
+		return (options) => {
+			let data = options?.data;
+			if (preset?.data) {
+				const result = preset.data["~standard"].validate(options?.data);
+				if (result instanceof Promise) throw new TypeError(`Schema validation for error "${String(p)}" returned a Promise. Async validation is not supported here; use a synchronous schema.`);
+				if (result.issues) throw new TypeError(JSON.stringify(result.issues, null, 2));
+				data = result.value;
+			}
+			return new KizloError(p, {
+				status: options?.status ?? preset?.status,
+				message: options?.message ?? preset?.message,
+				data
+			});
+		};
+	} });
+}
+
+//#endregion
+export { COMMON_ERRORS, KizloError, createThrowableErrorMap, defineErrorMap, isKizloError, toKizloError };

package/dist/shared/extension.d.ts

@@ -0,0 +1,25 @@
+import { EventHandler } from "../webhook/index.js";
+import { AnyProcedureRouter } from "./procedure.js";
+import { UnionToIntersection } from "@kizlo/shared";
+
+//#region src/shared/extension.d.ts
+interface ExtensionInitOptions {
+  context: {
+    something: string;
+  };
+}
+interface ExtensionInitResult<TRouter extends AnyProcedureRouter> {
+  router?: TRouter;
+  events?: EventHandler[];
+}
+interface Extension<TId extends string, TRouter extends AnyProcedureRouter> {
+  id: TId;
+  init: ExtensionInitFn<TRouter>;
+}
+type AnyExtension = Extension<any, AnyProcedureRouter>;
+type ExtensionInitFn<TRouter extends AnyProcedureRouter> = (context: ExtensionInitOptions) => ExtensionInitResult<TRouter>;
+type ExtractExtensionRouter<TExt extends AnyExtension> = TExt extends Extension<infer Name, infer Router> ? [keyof Router] extends [never] ? never : string extends keyof Router ? never : Record<Name, Router> : never;
+type InferExtensionRouter<TExt extends readonly AnyExtension[]> = TExt extends readonly [] ? Record<never, never> : ExtractExtensionRouter<TExt[number]> extends infer R ? [R] extends [never] ? Record<never, never> : UnionToIntersection<R> : never;
+declare function createExtension<TId extends string, TRouter extends AnyProcedureRouter = AnyProcedureRouter>(extension: Extension<TId, TRouter>): Extension<TId, TRouter>;
+//#endregion
+export { AnyExtension, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, InferExtensionRouter, createExtension };

package/dist/shared/extension.js

@@ -0,0 +1,7 @@
+//#region src/shared/extension.ts
+function createExtension(extension) {
+	return extension;
+}
+
+//#endregion
+export { createExtension };

package/dist/shared/identifier.d.ts

@@ -0,0 +1,11 @@
+//#region src/shared/identifier.d.ts
+type Identifier = {
+  type: "id";
+  value: number;
+} | {
+  type: "email" | "other";
+  value: string;
+};
+declare function parseIdentifier(value: unknown, maxLength?: number): Identifier | null;
+//#endregion
+export { Identifier, parseIdentifier };

package/dist/shared/identifier.js

@@ -0,0 +1,26 @@
+//#region src/shared/identifier.ts
+function parseIdentifier(value, maxLength = 200) {
+	const input = String(value).trim();
+	if (input.length === 0) return null;
+	if (input.length > maxLength) return null;
+	if (/^\d+$/.test(input)) {
+		const num = Number(input);
+		if (num <= 0 || num > Number.MAX_SAFE_INTEGER) return null;
+		return {
+			type: "id",
+			value: num
+		};
+	}
+	if (/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(input)) return {
+		type: "email",
+		value: input
+	};
+	if (!/^[a-zA-Z0-9._@-]+$/.test(input)) return null;
+	return {
+		type: "other",
+		value: input
+	};
+}
+
+//#endregion
+export { parseIdentifier };

package/dist/shared/middleware.d.ts

@@ -0,0 +1,29 @@
+import { AnyContext } from "./types.js";
+import { DefinedErrorMapLike, ThrowableErrorMap } from "./error.js";
+import { ServerContext } from "../context.js";
+import { UnionToIntersection } from "@kizlo/shared";
+
+//#region src/shared/middleware.d.ts
+interface MiddlewareResult<TOutContext extends AnyContext, TOutput> {
+  output: TOutput;
+  context: TOutContext;
+}
+type MiddlewareNextFn<TOutput> = {
+  (): Promise<MiddlewareResult<AnyContext, TOutput>>;
+  <UOutContext extends AnyContext>(options: {
+    context: UOutContext;
+  }): Promise<MiddlewareResult<UOutContext, TOutput>>;
+};
+type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = {
+  input: TInput;
+  context: ServerContext;
+  next: MiddlewareNextFn<TOutput>;
+  errors: ThrowableErrorMap<TError>;
+};
+type MiddlewareHandler<TOutContext extends AnyContext, TInput, TOutput, TError extends DefinedErrorMapLike> = (options: MiddlewareOptions<TInput, TOutput, TError>) => Promise<MiddlewareResult<TOutContext, TOutput>>;
+type Middleware<TOutContext extends AnyContext, TInput, TOutput, TError extends DefinedErrorMapLike> = MiddlewareHandler<TOutContext, TInput, TOutput, TError>;
+type AnyMiddleware = Middleware<any, any, any, any>;
+type ExtractMiddlewareContextOutput<M> = M extends Middleware<infer TOut, any, any, any> ? TOut : never;
+type InferUses<T extends readonly AnyMiddleware[] | undefined> = T extends readonly [] ? object : T extends readonly AnyMiddleware[] ? UnionToIntersection<ExtractMiddlewareContextOutput<T[number]>> : object;
+//#endregion
+export { InferUses };

package/dist/shared/procedure.d.ts

@@ -0,0 +1,114 @@
+import { AnyContext } from "./types.js";
+import { DefinedErrorMapLike, ThrowableErrorMap, WithCommonErrorMap } from "./error.js";
+import { ServerContext } from "../context.js";
+import { InferUses } from "./middleware.js";
+import * as _orpc_contract0 from "@orpc/contract";
+import { AnySchema, DeepMerge, Pathname, Prettify, Promisify, Schema, SchemaInput, SchemaOutput } from "@kizlo/shared";
+import * as _orpc_server0 from "@orpc/server";
+import { HTTPMethod } from "@orpc/server";
+import { JsonifiedValue } from "@orpc/openapi-client";
+
+//#region src/shared/procedure.d.ts
+type AnyProcedureRouter = {
+  [K: string]: AnyProcedure | AnyProcedureRouter;
+};
+type RouterDepthTuple = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type ExtractProcedureByScope<TRouter extends AnyProcedureRouter, TScope extends InvocationScope, TDepth extends number = 10> = TDepth extends 0 ? TRouter : { [K in keyof TRouter as TRouter[K] extends Procedure<infer Scope, infer _Input, infer _Output, infer _Errors> ? Scope extends TScope ? K : never : TRouter[K] extends AnyProcedureRouter ? keyof ExtractProcedureByScope<TRouter[K], TScope, RouterDepthTuple[TDepth]> extends never ? never : K : never]: TRouter[K] extends AnyProcedure ? TRouter[K] : TRouter[K] extends AnyProcedureRouter ? ExtractProcedureByScope<TRouter[K], TScope, RouterDepthTuple[TDepth]> : never };
+interface MiddlewareResult<TOutContext extends AnyContext, TOutput> {
+  output: TOutput;
+  context: TOutContext;
+}
+type MiddlewareNextFn<TOutput> = {
+  (): Promise<MiddlewareResult<AnyContext, TOutput>>;
+  <UOutContext extends AnyContext>(options: {
+    context: UOutContext;
+  }): Promise<MiddlewareResult<UOutContext, TOutput>>;
+};
+type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = {
+  input: TInput;
+  context: ServerContext;
+  next: MiddlewareNextFn<TOutput>;
+  errors: ThrowableErrorMap<TError>;
+};
+type MiddlewareHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TOutContext extends AnyContext> = (options: MiddlewareOptions<TInput, TOutput, TError>) => Promise<MiddlewareResult<TOutContext, TOutput>>;
+type Middleware<TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TOutContext extends AnyContext = AnyContext> = MiddlewareHandler<TInput, TOutput, TError, TOutContext>;
+type AnyMiddleware = Middleware<any, any, any, any>;
+type ExtractMiddlewareContextOutput<M> = M extends Middleware<infer TOut, any, any, any> ? TOut : never;
+declare function createMiddleware<TInput = any, TOutput = any, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TOutContext extends AnyContext = AnyContext>(handler: MiddlewareHandler<TInput, TOutput, TError, TOutContext>): Middleware<TInput, TOutput, TError, TOutContext>;
+type InvocationScope = "internal" | "remote" | "api";
+type ProcedureHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TContext extends ServerContext> = (ctx: {
+  input: TInput;
+  context: TContext;
+  errors: ThrowableErrorMap<WithCommonErrorMap<TError>>;
+}) => Promisify<TOutput>;
+interface Procedure<TScope extends InvocationScope, TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike> {
+  "~kizlo": {
+    uses: AnyMiddleware[];
+    handler: ProcedureHandler<TInput, TOutput, TError, ServerContext>;
+    options: {
+      scope: TScope;
+      errors?: TError;
+      output: AnySchema;
+      inputValidation?: boolean;
+      outputValidation?: boolean;
+      middlewares?: AnyMiddleware[];
+    } & ({
+      scope: "internal";
+      input?: AnySchema;
+    } | {
+      scope: "remote";
+      input?: AnySchema;
+      method?: HTTPMethod;
+    } | {
+      scope: "api";
+      method?: HTTPMethod;
+      path?: Pathname;
+      body?: AnySchema;
+      query?: AnySchema;
+      params?: AnySchema;
+      headers?: AnySchema;
+    });
+  };
+}
+type AnyProcedure = Procedure<InvocationScope, any, any, any>;
+type ProcedureContext<TMiddlewares extends AnyMiddleware[]> = ServerContext & InferUses<TMiddlewares>;
+type SchemaIO<TSchema, TMap extends "output" | "input"> = TMap extends "output" ? SchemaOutput<TSchema> : SchemaInput<TSchema>;
+type OpenapiPart<TKey extends string, TSchema, TMap extends "output" | "input"> = [TSchema] extends [never] ? unknown : [TSchema] extends [Schema] ? undefined extends SchemaIO<TSchema, TMap> ? { [K in TKey]?: SchemaIO<TSchema, TMap> } : { [K in TKey]: SchemaIO<TSchema, TMap> } : unknown;
+type ExtractParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}` ? { [K in Param | keyof ExtractParams<Rest>]: string } : object;
+type ResolveParamsPart<TPathname, TParams, TMap extends "output" | "input"> = [TPathname] extends [never] ? OpenapiPart<"params", TParams, TMap> : TPathname extends string ? ExtractParams<TPathname> extends infer TPath extends object ? keyof TPath extends never ? OpenapiPart<"params", TParams, TMap> : [TParams] extends [never] ? {
+  params: TPath;
+} : [TParams] extends [Schema] ? {
+  params: DeepMerge<TPath, TMap extends "output" ? SchemaOutput<TParams> : SchemaInput<TParams>>;
+} : {
+  params: TPath;
+} : OpenapiPart<"params", TParams, TMap> : OpenapiPart<"params", TParams, TMap>;
+type ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, TMap extends "output" | "input"> = OpenapiPart<"body", TBody, TMap> & ResolveParamsPart<TPathname, TParams, TMap> & OpenapiPart<"query", TQuery, TMap> & OpenapiPart<"headers", THeaders, TMap>;
+type ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders> = Prettify<TScope extends "api" ? ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, "output"> : [TInput] extends [Schema] ? SchemaOutput<TInput> : unknown>;
+type ResolvedSchemaInput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders> = Prettify<TScope extends "api" ? ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, "input"> : [TInput] extends [Schema] ? SchemaInput<TInput> : unknown>;
+type ProcedureOptions<TScope extends InvocationScope, TPathname extends Pathname, TInput extends Schema | undefined, TBody extends Schema | undefined, TParams extends Schema | undefined, TQuery extends Schema | undefined, THeaders extends Schema | undefined, TOutput extends Schema, TError extends DefinedErrorMapLike, TMiddlewares extends Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[]> = {
+  scope: TScope;
+  errors?: TError;
+  output: TOutput;
+  middlewares?: TMiddlewares;
+  inputValidation?: boolean;
+  outputValidation?: boolean;
+} & (TScope extends "api" ? {
+  method?: HTTPMethod;
+  path?: TPathname;
+  body?: TBody;
+  query?: TQuery;
+  params?: TParams;
+  headers?: THeaders;
+} : TScope extends "remote" ? {
+  input?: TInput;
+  method?: HTTPMethod;
+} : {
+  input?: TInput;
+});
+declare function createProcedure<TScope extends InvocationScope, TPathname extends Pathname, TInput extends Schema | undefined = undefined, TBody extends Schema | undefined = undefined, TParams extends Schema | undefined = undefined, TQuery extends Schema | undefined = undefined, THeaders extends Schema | undefined = undefined, TOutput extends Schema = Schema, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TMiddlewares extends Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[] = Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[], TContext extends ProcedureContext<TMiddlewares> = ProcedureContext<TMiddlewares>>(options: ProcedureOptions<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders, TOutput, TError, TMiddlewares>, handler: ProcedureHandler<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError, TContext>): Procedure<TScope, ResolvedSchemaInput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, TScope extends "api" ? JsonifiedValue<SchemaOutput<TOutput>> : SchemaOutput<TOutput>, TError>;
+declare function schemaType<TInput, TOutput = TInput>(schema?: AnySchema): Schema<TInput, TOutput>;
+declare function buildProcedure(procedure: AnyProcedure): _orpc_server0.DecoratedProcedure<_orpc_server0.Context & Record<never, never>, _orpc_server0.Context, _orpc_contract0.Schema<unknown, unknown>, _orpc_contract0.Schema<any, any>, Record<never, never>, Record<never, never>>;
+declare function handleUnexpectedError(error: unknown, errors?: DefinedErrorMapLike): never;
+declare function combineDetailed(parts: Record<string, AnySchema>): AnySchema;
+//#endregion
+export { AnyMiddleware, AnyProcedure, AnyProcedureRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, InvocationScope, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, Procedure, ProcedureContext, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createMiddleware, createProcedure, handleUnexpectedError, schemaType };

package/dist/shared/procedure.js

@@ -0,0 +1,114 @@
+import { COMMON_ERRORS, KizloError, createThrowableErrorMap, isKizloError } from "./error.js";
+import { os } from "@orpc/server";
+
+//#region src/shared/procedure.ts
+function createMiddleware(handler) {
+	return handler;
+}
+function createProcedure(options, handler) {
+	return { "~kizlo": {
+		options,
+		uses: options.middlewares ?? [],
+		handler: (ctx) => handler(ctx)
+	} };
+}
+function schemaType(schema) {
+	return schema ?? { "~standard": {
+		vendor: "custom",
+		version: 1,
+		async validate(value) {
+			return { value };
+		}
+	} };
+}
+function buildProcedure(procedure) {
+	const { handler, options, uses } = procedure["~kizlo"];
+	const errors = createThrowableErrorMap(options.errors ?? {});
+	const builder = os.$context().$config({
+		initialInputValidationIndex: options.inputValidation ?? true ? void 0 : NaN,
+		initialOutputValidationIndex: options.outputValidation ?? false ? void 0 : NaN
+	});
+	let chain = builder.meta({ scope: options.scope });
+	for (const middleware of uses) chain = chain.use(builder.middleware(async ({ next, context }, input) => {
+		try {
+			return await middleware({
+				input,
+				next,
+				context,
+				errors
+			});
+		} catch (error) {
+			handleUnexpectedError(error, options.errors);
+		}
+	}));
+	switch (options.scope) {
+		case "internal":
+			if (options.input) chain = chain.input(options.input);
+			break;
+		case "remote":
+			chain = chain.route({ method: options.method });
+			if (options.input) chain = chain.input(options.input);
+			break;
+		case "api": {
+			chain = chain.route({
+				path: options.path,
+				method: options.method,
+				inputStructure: "detailed"
+			});
+			const shape = {};
+			if (options.params) shape.params = options.params;
+			if (options.query) shape.query = options.query;
+			if (options.headers) shape.headers = options.headers;
+			if (options.body) shape.body = options.body;
+			if (Object.keys(shape).length > 0) chain = chain.input(combineDetailed(shape));
+			break;
+		}
+	}
+	if (options.output) chain = chain.output(options.output);
+	return chain.handler(async ({ context, input }) => {
+		try {
+			return await handler({
+				context,
+				input,
+				errors
+			});
+		} catch (error) {
+			handleUnexpectedError(error, options.errors);
+		}
+	});
+}
+function handleUnexpectedError(error, errors) {
+	const definedErrorMap = {
+		...COMMON_ERRORS,
+		...errors
+	};
+	if (isKizloError(error)) {
+		if (!definedErrorMap[error.code]) throw new KizloError("UNEXPECTED_ERROR", { cause: error });
+	}
+	throw error;
+}
+function combineDetailed(parts) {
+	return { "~standard": {
+		version: 1,
+		vendor: "kizlo",
+		validate: async (value) => {
+			if (typeof value !== "object" || value === null) return { issues: [{ message: "Expected object" }] };
+			const input = value;
+			const result = {};
+			const issues = [];
+			for (const [key, schema] of Object.entries(parts)) {
+				let r = schema["~standard"].validate(input[key]);
+				if (r instanceof Promise) r = await r;
+				if (r.issues) for (const issue of r.issues) issues.push({
+					...issue,
+					path: [key, ...issue.path ?? []]
+				});
+				else result[key] = r.value;
+			}
+			return issues.length ? { issues } : { value: result };
+		}
+	} };
+}
+
+//#endregion
+export { buildProcedure, combineDetailed, createMiddleware, createProcedure, handleUnexpectedError, schemaType };

package/dist/shared/result.d.ts

@@ -0,0 +1,24 @@
+import { DefinedErrorMapLike, KizloError, WithCommonErrorMap } from "./error.js";
+import { AnyProcedureRouter, Procedure } from "./procedure.js";
+import { NestedClient } from "@orpc/client";
+import { SchemaOutput } from "@kizlo/shared";
+
+//#region src/shared/result.d.ts
+type MaybeCallerOptions<UInput> = unknown extends UInput ? [] : [UInput] extends [undefined] ? [] : object extends UInput ? [input?: UInput] : [input: UInput];
+type ProcedureMethod<UInput, UOutput, TError extends DefinedErrorMapLike> = {
+  (...rest: MaybeCallerOptions<UInput>): Promise<KizloResult<UOutput, TError>>;
+  call: (...rest: MaybeCallerOptions<UInput>) => Promise<UOutput>;
+};
+type KizloErrorUnion<TErrors extends DefinedErrorMapLike> = { [K in Extract<keyof TErrors, string>]: KizloError<K, SchemaOutput<TErrors[K]["data"]>> }[Extract<keyof TErrors, string>];
+type KizloResult<TOutput, TErrors extends DefinedErrorMapLike = DefinedErrorMapLike> = {
+  data: TOutput;
+  error: null;
+  success: true;
+} | {
+  data: undefined;
+  error: KizloErrorUnion<WithCommonErrorMap<TErrors>>;
+  success: false;
+};
+type ResultClient<T extends AnyProcedureRouter> = { [K in keyof T]: T[K] extends Procedure<infer _Scope, infer Input, infer Output, infer Errors> ? ProcedureMethod<Input, Output, Errors> : T[K] extends AnyProcedureRouter ? ResultClient<T[K]> : never };
+//#endregion
+export { ResultClient };

package/dist/shared/result.js

@@ -0,0 +1,49 @@
+import { toKizloError } from "./error.js";
+
+//#region src/shared/result.ts
+function createResultClient(client) {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy(typeof client === "function" ? client : () => {}, {
+		async apply(_, __, args) {
+			if (typeof client !== "function") throw new Error("This client node is not callable");
+			try {
+				return {
+					data: await client(...args),
+					error: null,
+					success: true
+				};
+			} catch (e) {
+				return {
+					data: void 0,
+					error: toKizloError(e),
+					success: false
+				};
+			}
+		},
+		get(_, prop, receiver) {
+			if (cache.has(prop)) return cache.get(prop);
+			if (prop === "call" && typeof client === "function") {
+				const unsafe = async (...args) => {
+					try {
+						return await client(...args);
+					} catch (e) {
+						throw toKizloError(e);
+					}
+				};
+				cache.set(prop, unsafe);
+				return unsafe;
+			}
+			const value = Reflect.get(client, prop, receiver);
+			if (typeof prop !== "string" || !isRecordLike(value)) return value;
+			const wrapped = createResultClient(value);
+			cache.set(prop, wrapped);
+			return wrapped;
+		}
+	});
+}
+function isRecordLike(value) {
+	return !!value && (typeof value === "object" || typeof value === "function");
+}
+
+//#endregion
+export { createResultClient };