silgi 0.0.13 → 0.1.0-beta.1

package/dist/contract.mjs

@@ -0,0 +1,40 @@
+//#region src/contract.ts
+/**
+* Define an API contract — shared between client and server.
+* Pure type information, no runtime behavior.
+*/
+function contract(definition) {
+	return definition;
+}
+/**
+* Implement a contract — returns a silgi RouterDef.
+* Type-safe: implementation must match the contract.
+*/
+function implement(contractDef, implementations) {
+	return buildRouter(contractDef, implementations);
+}
+function buildRouter(contractDef, impls) {
+	const router = {};
+	for (const [key, contractEntry] of Object.entries(contractDef)) {
+		const impl = impls[key];
+		if (!impl) continue;
+		if (isProcedureContract(contractEntry)) router[key] = {
+			type: contractEntry.type ?? "query",
+			input: contractEntry.input ?? null,
+			output: contractEntry.output ?? null,
+			errors: contractEntry.errors ?? null,
+			use: null,
+			resolve: impl,
+			route: contractEntry.route ?? null,
+			meta: null
+		};
+		else router[key] = buildRouter(contractEntry, impl);
+	}
+	return router;
+}
+function isProcedureContract(v) {
+	if (typeof v !== "object" || v === null) return false;
+	return "input" in v || "output" in v || "type" in v || "errors" in v;
+}
+//#endregion
+export { contract, implement };

package/dist/core/error.d.mts

@@ -0,0 +1,104 @@
+//#region src/core/error.d.ts
+/**
+ * SilgiError — unified RPC error with cross-realm instanceof.
+ */
+declare const COMMON_ERRORS: Readonly<{
+  readonly BAD_REQUEST: {
+    readonly status: 400;
+    readonly message: "Bad Request";
+  };
+  readonly UNAUTHORIZED: {
+    readonly status: 401;
+    readonly message: "Unauthorized";
+  };
+  readonly FORBIDDEN: {
+    readonly status: 403;
+    readonly message: "Forbidden";
+  };
+  readonly NOT_FOUND: {
+    readonly status: 404;
+    readonly message: "Not Found";
+  };
+  readonly METHOD_NOT_ALLOWED: {
+    readonly status: 405;
+    readonly message: "Method Not Allowed";
+  };
+  readonly NOT_ACCEPTABLE: {
+    readonly status: 406;
+    readonly message: "Not Acceptable";
+  };
+  readonly CONFLICT: {
+    readonly status: 409;
+    readonly message: "Conflict";
+  };
+  readonly GONE: {
+    readonly status: 410;
+    readonly message: "Gone";
+  };
+  readonly UNPROCESSABLE_CONTENT: {
+    readonly status: 422;
+    readonly message: "Unprocessable Content";
+  };
+  readonly PRECONDITION_REQUIRED: {
+    readonly status: 428;
+    readonly message: "Precondition Required";
+  };
+  readonly TOO_MANY_REQUESTS: {
+    readonly status: 429;
+    readonly message: "Too Many Requests";
+  };
+  readonly CLIENT_CLOSED_REQUEST: {
+    readonly status: 499;
+    readonly message: "Client Closed Request";
+  };
+  readonly INTERNAL_SERVER_ERROR: {
+    readonly status: 500;
+    readonly message: "Internal Server Error";
+  };
+  readonly NOT_IMPLEMENTED: {
+    readonly status: 501;
+    readonly message: "Not Implemented";
+  };
+  readonly BAD_GATEWAY: {
+    readonly status: 502;
+    readonly message: "Bad Gateway";
+  };
+  readonly SERVICE_UNAVAILABLE: {
+    readonly status: 503;
+    readonly message: "Service Unavailable";
+  };
+  readonly GATEWAY_TIMEOUT: {
+    readonly status: 504;
+    readonly message: "Gateway Timeout";
+  };
+}>;
+type SilgiErrorCode = keyof typeof COMMON_ERRORS | (string & {});
+interface SilgiErrorOptions<TData = unknown> {
+  status?: number;
+  message?: string;
+  data?: TData;
+  cause?: unknown;
+  defined?: boolean;
+}
+interface SilgiErrorJSON<TCode extends string = string, TData = unknown> {
+  defined: boolean;
+  code: TCode;
+  status: number;
+  message: string;
+  data: TData;
+}
+declare class SilgiError<TCode extends string = string, TData = unknown> extends Error {
+  readonly code: TCode;
+  readonly status: number;
+  readonly data: TData;
+  readonly defined: boolean;
+  constructor(code: TCode, options?: SilgiErrorOptions<TData>);
+  toJSON(): SilgiErrorJSON<TCode, TData>;
+  static [Symbol.hasInstance](instance: unknown): boolean;
+}
+declare function isDefinedError<TError>(error: TError): error is TError & SilgiError & {
+  defined: true;
+};
+declare function toSilgiError(error: unknown): SilgiError;
+//#endregion
+export { SilgiError, SilgiErrorCode, SilgiErrorJSON, SilgiErrorOptions, isDefinedError, toSilgiError };

package/dist/core/error.mjs

@@ -0,0 +1,139 @@
+//#region src/core/error.ts
+/**
+* SilgiError — unified RPC error with cross-realm instanceof.
+*/
+const COMMON_ERRORS = /* @__PURE__ */ Object.freeze({
+	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_ALLOWED: {
+		status: 405,
+		message: "Method Not Allowed"
+	},
+	NOT_ACCEPTABLE: {
+		status: 406,
+		message: "Not Acceptable"
+	},
+	CONFLICT: {
+		status: 409,
+		message: "Conflict"
+	},
+	GONE: {
+		status: 410,
+		message: "Gone"
+	},
+	UNPROCESSABLE_CONTENT: {
+		status: 422,
+		message: "Unprocessable Content"
+	},
+	PRECONDITION_REQUIRED: {
+		status: 428,
+		message: "Precondition Required"
+	},
+	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"
+	}
+});
+const REGISTRY_KEY = Symbol.for("silgi.error.registry");
+const registry = globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new WeakSet();
+var SilgiError = class extends Error {
+	code;
+	status;
+	data;
+	defined;
+	constructor(code, options = {}) {
+		const defaults = COMMON_ERRORS[code];
+		const message = options.message ?? defaults?.message ?? code;
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.code = code;
+		this.status = options.status ?? defaults?.status ?? 500;
+		this.data = options.data;
+		this.defined = options.defined ?? false;
+		this.name = "SilgiError";
+	}
+	toJSON() {
+		return {
+			defined: this.defined,
+			code: this.code,
+			status: this.status,
+			message: this.message,
+			data: this.data
+		};
+	}
+	static {
+		registry.add(this);
+	}
+	static [Symbol.hasInstance](instance) {
+		if (typeof instance !== "object" || instance === null) return false;
+		let proto = Object.getPrototypeOf(instance);
+		while (proto) {
+			if (proto.constructor && registry.has(proto.constructor)) return true;
+			proto = Object.getPrototypeOf(proto);
+		}
+		return false;
+	}
+};
+function isDefinedError(error) {
+	return error instanceof SilgiError && error.defined === true;
+}
+function toSilgiError(error) {
+	if (error instanceof SilgiError) return error;
+	return new SilgiError("INTERNAL_SERVER_ERROR", {
+		message: "Internal server error",
+		cause: error
+	});
+}
+function isErrorStatus(status) {
+	return status >= 400;
+}
+function isSilgiErrorJSON(json) {
+	return typeof json === "object" && json !== null && "code" in json && "status" in json && typeof json.code === "string";
+}
+function fromSilgiErrorJSON(json) {
+	return new SilgiError(json.code, {
+		status: json.status,
+		message: json.message,
+		data: json.data,
+		defined: json.defined
+	});
+}
+//#endregion
+export { SilgiError, fromSilgiErrorJSON, isDefinedError, isErrorStatus, isSilgiErrorJSON, toSilgiError };