@snail-js/api 0.1.27 → 1.0.0

package/dist/adapter/plain.d.ts

@@ -0,0 +1,12 @@
+import type { SnailStateAdapter } from "../typings/adapter.js";
+/**
+ * Framework-free state adapter.
+ *
+ * A plain mutable box. Values update correctly, they just do not *trigger*
+ * anything — which is exactly right for a test, an SSR pass or a script, and is
+ * the safe default when no UI framework is present.
+ *
+ * A framework adapter registered with `setStateAdapter` replaces it.
+ */
+export declare const plainStateAdapter: SnailStateAdapter;
+//# sourceMappingURL=plain.d.ts.map

package/dist/adapter/plain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain.d.ts","sourceRoot":"","sources":["../../src/adapter/plain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,oBAAoB,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAc/B,CAAC"}

package/dist/adapter/react.d.ts

@@ -0,0 +1,14 @@
+import type { SnailStateAdapter } from "../typings/adapter.js";
+/**
+ * React state adapter.
+ *
+ * `create` returns a subscribable box; `useBind` is what a component calls during
+ * render to subscribe and re-render. Strategies therefore work in both a
+ * component (via `useBind`) and an event handler (via `read`).
+ *
+ * This module is the only place in the library that imports `react`. It is
+ * reachable solely from `@snail-js/api/strategies/react` and the `ReactAdapter`
+ * plugin.
+ */
+export declare const reactStateAdapter: SnailStateAdapter;
+//# sourceMappingURL=react.d.ts.map

package/dist/adapter/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/adapter/react.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,oBAAoB,CAAC;AAqB3E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAsD/B,CAAC"}

package/dist/adapter/registry.d.ts

@@ -0,0 +1,16 @@
+import type { SnailStateAdapter, SnailStateRef } from "../typings/adapter.js";
+/** Replace the active adapter. Called once by a framework entry point. */
+export declare function setStateAdapter(adapter: SnailStateAdapter): void;
+/** The active adapter. */
+export declare function getStateAdapter(): SnailStateAdapter;
+/** `true` when an adapter other than the framework-free default is installed. */
+export declare function hasFrameworkAdapter(): boolean;
+/** Create a tracked value with the active adapter. */
+export declare function createState<T>(initial: T): SnailStateRef<T>;
+/** Read a tracked value. */
+export declare function readState<T>(ref: SnailStateRef<T>): T;
+/** Write a tracked value. */
+export declare function writeState<T>(ref: SnailStateRef<T>, value: T): void;
+/** Release a tracked value, if the adapter allocated anything. */
+export declare function disposeState<T>(ref: SnailStateRef<T>): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/adapter/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/adapter/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAY3E,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAOhE;AAED,0BAA0B;AAC1B,wBAAgB,eAAe,IAAI,iBAAiB,CAEnD;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED,sDAAsD;AACtD,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAE3D;AAED,4BAA4B;AAC5B,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAErD;AAED,6BAA6B;AAC7B,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAEnE;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAE3D"}

package/dist/adapter/vue.d.ts

@@ -0,0 +1,15 @@
+import type { SnailStateAdapter } from "../typings/adapter.js";
+/**
+ * Vue 3 state adapter.
+ *
+ * A Vue `Ref<T>` already *is* a `{ value: T }` box, so this adapter is almost
+ * pure identity — `create` hands back the ref and `read`/`write` touch `.value`.
+ * Vue's render effect tracks the `.value` access itself, which is why no
+ * `subscribe` implementation is needed: there is nothing to notify manually.
+ *
+ * This module is the only place in the library that imports `vue`, and it is only
+ * reachable from the strategies' default entry point and the `VueAdapter` plugin.
+ * Applications that never import either never pull Vue in.
+ */
+export declare const vueStateAdapter: SnailStateAdapter;
+//# sourceMappingURL=vue.d.ts.map

package/dist/adapter/vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.d.ts","sourceRoot":"","sources":["../../src/adapter/vue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,oBAAoB,CAAC;AAE3E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,iBAmB7B,CAAC"}

package/dist/chunks/custom-UchOSg_s.js

@@ -0,0 +1,466 @@
+import { B as SnailError, b as t, p as sourceLabel, u as paramResolvers, z as SnailDecoratorError } from "./plugin-D3RDffDG.js";
+import { d as LOG_LEVEL_WEIGHT } from "./response-D-ubkAFl.js";
+//#region src/core/logger.ts
+/** Create a logger honouring `@Server({ logLevel })`. */
+function createLogger(level = "silent") {
+	const threshold = LOG_LEVEL_WEIGHT[level] ?? 0;
+	return {
+		level,
+		enabled(candidate) {
+			return threshold >= LOG_LEVEL_WEIGHT[candidate];
+		},
+		error(message, ...rest) {
+			if (threshold >= LOG_LEVEL_WEIGHT.error) console.error(message, ...rest);
+		},
+		warn(message, ...rest) {
+			if (threshold >= LOG_LEVEL_WEIGHT.warn) console.warn(message, ...rest);
+		},
+		info(message, ...rest) {
+			if (threshold >= LOG_LEVEL_WEIGHT.info) console.info(message, ...rest);
+		},
+		debug(message, ...rest) {
+			if (threshold >= LOG_LEVEL_WEIGHT.debug) console.debug(message, ...rest);
+		}
+	};
+}
+//#endregion
+//#region src/core/metadata.keys.ts
+/**
+* Metadata keys used by every `@snail-js/api` decorator.
+*
+* `Symbol.for` is used instead of plain `Symbol()` on purpose: a monorepo can
+* easily end up with two copies of this package (one hoisted for the app, one
+* nested under a dependency). Global symbol registration keeps both copies
+* reading and writing the *same* metadata slots.
+*/
+/** `@Server(...)` options, stored on the server class. */
+var SNAIL_SERVER_OPTIONS = Symbol.for("@snail-js/api:server-options");
+/** `@Api(...)` options, stored on the api class. */
+var SNAIL_API_OPTIONS = Symbol.for("@snail-js/api:api-options");
+/** `@Get(...)` / `@Post(...)` / … options, stored per method. */
+var SNAIL_REQUEST_METHOD = Symbol.for("@snail-js/api:request-method");
+/** `@Params()` / `@Query()` / `@Data()` parameter descriptors, stored per method. */
+var SNAIL_PARAMS = Symbol.for("@snail-js/api:params");
+/** `@Header(...)` records, stored on the api class and per method. */
+var SNAIL_HEADERS = Symbol.for("@snail-js/api:headers");
+/** `@UploadProgress(...)` callback, stored per method. */
+var SNAIL_UPLOAD_PROGRESS = Symbol.for("@snail-js/api:upload-progress");
+/** `@DownloadProgress(...)` callback, stored per method. */
+var SNAIL_DOWNLOAD_PROGRESS = Symbol.for("@snail-js/api:download-progress");
+/** `@Sse(...)` options, stored on the stream class. */
+var SNAIL_SSE_OPTIONS = Symbol.for("@snail-js/api:sse-options");
+/** `@SseEvent(...)` / `@OnSseOpen()` / `@OnSseError()` handlers, stored on the stream class. */
+var SNAIL_SSE_HANDLERS = Symbol.for("@snail-js/api:sse-handlers");
+/** `@WebSocket(...)` options, stored on the stream class. */
+var SNAIL_WS_OPTIONS = Symbol.for("@snail-js/api:ws-options");
+/** `@OnWsOpen()` / `@OnWsMessage()` / … handlers, stored on the stream class. */
+var SNAIL_WS_HANDLERS = Symbol.for("@snail-js/api:ws-handlers");
+/** `@HttpStream(...)` options, stored per method. */
+var SNAIL_HTTP_STREAM = Symbol.for("@snail-js/api:http-stream");
+/**
+* Prefix reserved for third-party decorators built with
+* {@link createParamDecorator} and friends.
+*
+* Plugin authors should namespace their key, e.g.
+* `Symbol.for("@acme/snail-plugin:tenant")`, so two plugins can never collide.
+*/
+var SNAIL_CUSTOM_KEY_PREFIX = "@snail-js/api:custom:";
+//#endregion
+//#region src/core/metadata.ts
+/**
+* A dependency-free replacement for `reflect-metadata`.
+*
+* ## Why not `reflect-metadata`?
+*
+* TypeScript 7 dropped the ability to emit `design:*` metadata: enabling
+* `emitDecoratorMetadata` is accepted but silently emits nothing (verified
+* against `tsc` 7.0.2 — the `__metadata` helper is emitted, the calls are not).
+* That removes the only capability `reflect-metadata` ever provided to this
+* library: we have never needed inferred constructor parameter types, only the
+* metadata our *own* decorators write.
+*
+* Dropping it buys three things:
+*   1. no runtime polyfill to install or import at the app entry point;
+*   2. one fewer entry in `dependencies` — axios stays the only one;
+*   3. deterministic behaviour on every runtime (browser, Node, worker, edge)
+*      because the polyfill's `Reflect.defineMetadata` is not involved at all.
+*
+* Legacy decorators (`experimentalDecorators: true`) and parameter decorators
+* remain fully supported by TypeScript 7.
+*
+* ## Storage model
+*
+* ```text
+* WeakMap<owner, Map<slot, Map<key, value>>>
+*                 │       └── the decorator's symbol key
+*                 └── CLASS_SLOT for class metadata, else the method name
+* ```
+*
+* `owner` is always a *class* (constructor function). A decorator applied to a
+* method or parameter receives the prototype, so {@link resolveOwner} maps it
+* back to the class.
+*
+* ## Decorator application order (important)
+*
+* For `@Api("/u") class U { @Get() list(@Query("a") a: string) {} }` the
+* runtime order is:
+*
+* ```text
+*   1. parameter decorators   (reverse index order)
+*   2. method decorators
+*   3. class decorators
+* ```
+*
+* Every writer below therefore *merges*; none of them may clobber an existing
+* value. Array-shaped metadata is appended, never replaced.
+*/
+/** Internal slot used for class-level (non method-specific) metadata. */
+var CLASS_SLOT = Symbol.for("@snail-js/api:class-slot");
+var registry = /* @__PURE__ */ new WeakMap();
+/**
+* Normalise whatever a decorator receives into the class that owns the metadata.
+*
+* - class decorator → the constructor itself
+* - method / parameter decorator → `prototype.constructor`
+* - a bare prototype passed by hand → `prototype.constructor`
+*/
+function resolveOwner(target) {
+	if (typeof target === "function") return target;
+	if (target !== null && typeof target === "object") {
+		const ctor = target.constructor;
+		if (typeof ctor === "function") return ctor;
+	}
+	throw new TypeError("[snail] metadata target must be a class, a prototype or a constructor function");
+}
+function slotOf(propertyKey) {
+	return propertyKey ?? CLASS_SLOT;
+}
+function findSlotMap(owner, slot) {
+	return registry.get(owner)?.get(slot);
+}
+function ensureSlotMap(owner, slot) {
+	let record = registry.get(owner);
+	if (!record) {
+		record = /* @__PURE__ */ new Map();
+		registry.set(owner, record);
+	}
+	let slotMap = record.get(slot);
+	if (!slotMap) {
+		slotMap = /* @__PURE__ */ new Map();
+		record.set(slot, slotMap);
+	}
+	return slotMap;
+}
+/**
+* Write metadata, replacing any value previously written for the same
+* (owner, slot, key) triple.
+*/
+function defineMetadata(key, value, target, propertyKey) {
+	ensureSlotMap(resolveOwner(target), slotOf(propertyKey)).set(key, value);
+}
+/** Read metadata from exactly this owner, ignoring the prototype chain. */
+function getOwnMetadata(key, target, propertyKey) {
+	return findSlotMap(resolveOwner(target), slotOf(propertyKey))?.get(key);
+}
+/**
+* Read metadata, walking the class prototype chain so a base api class or a base
+* server class can supply defaults to its subclasses.
+*/
+function getMetadata(key, target, propertyKey) {
+	const slot = slotOf(propertyKey);
+	let owner = resolveOwner(target);
+	while (owner && owner !== Function.prototype && owner !== Object.prototype) {
+		const slotMap = findSlotMap(owner, slot);
+		if (slotMap?.has(key)) return slotMap.get(key);
+		owner = Object.getPrototypeOf(owner);
+	}
+}
+/** `true` when {@link getMetadata} would find something. */
+function hasMetadata(key, target, propertyKey) {
+	return getMetadata(key, target, propertyKey) !== void 0;
+}
+/**
+* Append to array-shaped metadata, always creating a fresh array.
+*
+* Copy-on-write matters: several decorators legitimately contribute to one key
+* (four `@Query()` parameters, a class-level `@Header()` plus a method-level
+* one) and the array must never be shared with a base class.
+*/
+function appendMetadata(key, value, target, propertyKey) {
+	const previous = getOwnMetadata(key, target, propertyKey);
+	defineMetadata(key, previous ? [...previous, value] : [value], target, propertyKey);
+}
+/** Merge a record into record-shaped metadata (class-level `@Header` and friends). */
+function mergeMetadata(key, value, target, propertyKey) {
+	const previous = getOwnMetadata(key, target, propertyKey);
+	defineMetadata(key, previous ? {
+		...previous,
+		...value
+	} : { ...value }, target, propertyKey);
+}
+/** Delete metadata from exactly this owner. Returns whether anything was removed. */
+function deleteMetadata(key, target, propertyKey) {
+	return findSlotMap(resolveOwner(target), slotOf(propertyKey))?.delete(key) ?? false;
+}
+/**
+* Collect every method name that carries metadata for `key`, walking the class
+* prototype chain from base to derived so subclasses may override.
+*/
+function collectMethodKeys(key, target) {
+	const chain = [];
+	let owner = resolveOwner(target);
+	while (owner && owner !== Function.prototype && owner !== Object.prototype) {
+		chain.unshift(owner);
+		owner = Object.getPrototypeOf(owner);
+	}
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const current of chain) {
+		const record = registry.get(current);
+		if (!record) continue;
+		for (const [slot, slotMap] of record) {
+			if (slot === CLASS_SLOT || !slotMap.has(key)) continue;
+			const name = String(slot);
+			if (seen.has(name)) continue;
+			seen.add(name);
+			result.push(name);
+		}
+	}
+	return result;
+}
+/**
+* Test-only escape hatch: swap the registry for a fresh `WeakMap`. Existing
+* owners become unreachable and are garbage collected.
+*/
+function clearMetadataRegistry() {
+	registry = /* @__PURE__ */ new WeakMap();
+}
+//#endregion
+//#region src/error/plugin.ts
+/** Thrown for plugin registration, dependency and uninstall failures. */
+var SnailPluginError = class extends SnailError {
+	constructor(message, options = {}) {
+		super(message, {
+			code: "SNAIL_PLUGIN_ERROR",
+			cause: options.cause
+		});
+		this.pluginName = options.pluginName;
+	}
+};
+//#endregion
+//#region src/decorators/args.ts
+/** Normalise `"key"` / `{ key, ...options }` / `undefined`. */
+function normalizeParamInput(input) {
+	if (input === void 0) return {
+		key: void 0,
+		options: void 0
+	};
+	if (typeof input === "string") return {
+		key: input,
+		options: void 0
+	};
+	if (input === null || typeof input !== "object") throw new SnailDecoratorError(t("error.decorator.param.untyped", "Source"));
+	const { key, ...options } = input;
+	return {
+		key,
+		options: Object.keys(options).length > 0 ? options : void 0
+	};
+}
+/**
+* Write one parameter descriptor onto the decorated method.
+*
+* Parameter decorators run *before* the method decorator and in reverse index
+* order, so this only ever appends — the descriptor list is sorted by index when
+* the arguments are applied.
+*/
+function defineParamDescriptor(source, resolver, input, target, propertyKey, index) {
+	if (propertyKey === void 0) throw new SnailDecoratorError(t("error.decorator.param.context", sourceLabel(source)));
+	const { key, options } = normalizeParamInput(input);
+	appendMetadata(SNAIL_PARAMS, {
+		source,
+		index,
+		key,
+		options,
+		resolve: resolver
+	}, target, propertyKey);
+}
+/**
+* Build a parameter decorator for a registered source.
+*
+* Built-in sources are `params`, `query`, `data` and `header`. A plugin can add
+* its own with `createPlugin`'s `defineParamSource`.
+*/
+function createParamDecoratorFor(source) {
+	return (input) => {
+		if (typeof input === "string" && input.length === 0) throw new SnailDecoratorError(t("error.decorator.param.untyped", sourceLabel(source)));
+		return (target, propertyKey, index) => {
+			const resolver = paramResolvers[source];
+			if (!resolver) throw new SnailDecoratorError(`[snail] no resolver registered for parameter source "${source}"`);
+			defineParamDescriptor(source, resolver, input, target, propertyKey, index);
+		};
+	};
+}
+/**
+* Path placeholders.
+*
+* ```ts
+* @Api("/user")
+* class UserApi {
+*   @Get("/:id/:tab")
+*   get(@Params("id") id: string, @Params("tab") tab: string) {}
+*   // or, equivalently
+*   @Get("/:id/:tab")
+*   get(@Params() params: { id: string; tab: string }) {}
+* }
+* ```
+*/
+var Params = createParamDecoratorFor("params");
+/**
+* Query string parameters.
+*
+* ```ts
+* @Get("/list")
+* list(@Query("page") page: number, @Query() filters: { q?: string }) {}
+* ```
+*/
+var Query = createParamDecoratorFor("query");
+/**
+* Request body.
+*
+* Keyed arguments merge into an object body. A key-less plain object merges too,
+* while any other value (`FormData`, `Blob`, a raw string, an array) replaces the
+* body outright so non-JSON uploads stay possible.
+*/
+var Data = createParamDecoratorFor("data");
+/**
+* A single request header.
+*
+* ```ts
+* @Get("/me")
+* me(@HeaderValue("authorization") token: string) {}
+* ```
+*
+* For *static* headers use the class/method level `@Header({ ... })` instead.
+*/
+var HeaderValue = createParamDecoratorFor("header");
+/** Legacy alias — the pre-rewrite library exposed the header source as `Header`. */
+var HeaderParam = HeaderValue;
+//#endregion
+//#region src/decorators/custom.ts
+/**
+* Extension factories for third-party decorators.
+*
+* The library's own decorators are built from these, so anything the core can do
+* a plugin can do too.
+*
+* ## Key namespacing
+*
+* Custom keys are derived from a name you supply:
+*
+* ```ts
+* const TENANT = customMetadataKey("acme/tenant");
+* ```
+*
+* Prefix your name with your package to make collisions impossible. The reserved
+* prefix `@snail-js/api:` belongs to the core.
+*/
+/** Build a namespaced metadata key for a custom decorator. */
+function customMetadataKey(name) {
+	if (typeof name !== "string" || name.length === 0) throw new SnailDecoratorError("[snail] customMetadataKey() requires a non-empty name");
+	return Symbol.for(`${SNAIL_CUSTOM_KEY_PREFIX}${name}`);
+}
+/**
+* Create a **parameter** decorator.
+*
+* ```ts
+* // 1. register a source (usually inside a plugin's setup)
+* api.defineParamSource("tenant", ({ ctx, value }) => {
+*   ctx.request.headers.set("x-tenant", String(value));
+* });
+*
+* // 2. expose a decorator built on it
+* export const Tenant = createParamDecorator("tenant");
+*
+* // 3. use it
+* @Get("/orders")
+* orders(@Tenant() tenantId: string) {}
+* ```
+*
+* Pass an explicit `resolver` to skip step 1 and keep everything in one place.
+*/
+function createParamDecorator(source, resolver) {
+	return (input) => {
+		const effective = resolver ?? paramResolvers[source];
+		if (!effective) throw new SnailDecoratorError(`[snail] no resolver registered for parameter source "${source}"; register one with createPlugin({ setup: (o, api) => api.defineParamSource("${source}", fn) }) or pass a resolver to createParamDecorator()`);
+		return (target, propertyKey, index) => {
+			defineParamDescriptor(source, effective, input, target, propertyKey, index);
+		};
+	};
+}
+/**
+* Create a **class** decorator.
+*
+* ```ts
+* export const Entity = createClassDecorator<string>("acme/entity");
+* @Entity("orders") class OrderApi {}
+* ```
+*
+* @param name metadata key name
+* @param merge when `true` (the default) repeated applications keep every value
+*   in an array instead of overwriting
+*/
+function createClassDecorator(name, merge = true) {
+	const key = customMetadataKey(name);
+	return (value) => (target) => {
+		if (merge) appendMetadata(key, value, target);
+		else defineMetadata(key, value, target);
+	};
+}
+/**
+* Create a **method** decorator.
+*
+* ```ts
+* export const Retry = createMethodDecorator<number>("acme/retry");
+* @Get("/flaky") @Retry(3) flaky() {}
+* ```
+*/
+function createMethodDecorator(name, merge = true) {
+	const key = customMetadataKey(name);
+	return (value) => (target, propertyKey) => {
+		if (propertyKey === void 0) throw new SnailDecoratorError(`[snail] createMethodDecorator("${name}") must decorate a method`);
+		if (merge) appendMetadata(key, value, target, propertyKey);
+		else defineMetadata(key, value, target, propertyKey);
+	};
+}
+/** Read metadata written by a custom method decorator. */
+function getMethodMetadata(name, target, methodName) {
+	return getMetadata(customMetadataKey(name), target, methodName);
+}
+/** Read metadata written by a custom class decorator. */
+function getClassMetadata(name, target) {
+	return getMetadata(customMetadataKey(name), target);
+}
+/** Read metadata written by a custom method decorator on exactly this class. */
+function getOwnMethodMetadata(name, target, methodName) {
+	return getOwnMetadata(customMetadataKey(name), target, methodName);
+}
+/**
+* Create a **property** decorator.
+*
+* Property decorators are handy for DTO classes consumed by the transform plugin:
+*
+* ```ts
+* const Alias = createPropertyDecorator<string>("acme/alias");
+* class UserDto { @Alias("user_name") userName!: string }
+* ```
+*/
+function createPropertyDecorator(name) {
+	const key = customMetadataKey(name);
+	return (value) => (target, propertyKey) => {
+		defineMetadata(key, value, target, propertyKey);
+	};
+}
+//#endregion
+export { SNAIL_DOWNLOAD_PROGRESS as A, SNAIL_WS_OPTIONS as B, getMetadata as C, resolveOwner as D, mergeMetadata as E, SNAIL_SERVER_OPTIONS as F, SNAIL_SSE_HANDLERS as I, SNAIL_SSE_OPTIONS as L, SNAIL_HTTP_STREAM as M, SNAIL_PARAMS as N, SNAIL_API_OPTIONS as O, SNAIL_REQUEST_METHOD as P, SNAIL_UPLOAD_PROGRESS as R, deleteMetadata as S, hasMetadata as T, createLogger as V, SnailPluginError as _, customMetadataKey as a, collectMethodKeys as b, getOwnMethodMetadata as c, HeaderValue as d, Params as f, normalizeParamInput as g, defineParamDescriptor as h, createPropertyDecorator as i, SNAIL_HEADERS as j, SNAIL_CUSTOM_KEY_PREFIX as k, Data as l, createParamDecoratorFor as m, createMethodDecorator as n, getClassMetadata as o, Query as p, createParamDecorator as r, getMethodMetadata as s, createClassDecorator as t, HeaderParam as u, appendMetadata as v, getOwnMetadata as w, defineMetadata as x, clearMetadataRegistry as y, SNAIL_WS_HANDLERS as z };
+
+//# sourceMappingURL=custom-UchOSg_s.js.map

package/dist/chunks/custom-UchOSg_s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-UchOSg_s.js","names":[],"sources":["../../src/core/logger.ts","../../src/core/metadata.keys.ts","../../src/core/metadata.ts","../../src/error/plugin.ts","../../src/decorators/args.ts","../../src/decorators/custom.ts"],"sourcesContent":["import { LOG_LEVEL_WEIGHT } from \"../default/options\";\nimport type { SnailLogLevel } from \"../typings/server\";\n\n/**\n * Level-gated logger.\n *\n * The pre-rewrite code called bare `console.log` from the middle of the request\n * pipeline, which made a request library noisy by default and impossible to\n * silence. Every diagnostic now goes through a logger whose level comes from\n * `@Server({ logLevel })`, and the default level is `\"silent\"`.\n */\nexport interface SnailLogger {\n  /** Active level. */\n  readonly level: SnailLogLevel;\n  /** `true` when a message at `level` would be printed. */\n  enabled(level: Exclude<SnailLogLevel, \"silent\">): boolean;\n  error(message: string, ...rest: unknown[]): void;\n  warn(message: string, ...rest: unknown[]): void;\n  info(message: string, ...rest: unknown[]): void;\n  debug(message: string, ...rest: unknown[]): void;\n}\n\n/** Create a logger honouring `@Server({ logLevel })`. */\nexport function createLogger(level: SnailLogLevel = \"silent\"): SnailLogger {\n  const threshold = LOG_LEVEL_WEIGHT[level] ?? 0;\n\n  return {\n    level,\n    enabled(candidate) {\n      return threshold >= LOG_LEVEL_WEIGHT[candidate];\n    },\n    error(message, ...rest) {\n      if (threshold >= LOG_LEVEL_WEIGHT.error) console.error(message, ...rest);\n    },\n    warn(message, ...rest) {\n      if (threshold >= LOG_LEVEL_WEIGHT.warn) console.warn(message, ...rest);\n    },\n    info(message, ...rest) {\n      if (threshold >= LOG_LEVEL_WEIGHT.info) console.info(message, ...rest);\n    },\n    debug(message, ...rest) {\n      if (threshold >= LOG_LEVEL_WEIGHT.debug) console.debug(message, ...rest);\n    }\n  };\n}\n","/**\n * Metadata keys used by every `@snail-js/api` decorator.\n *\n * `Symbol.for` is used instead of plain `Symbol()` on purpose: a monorepo can\n * easily end up with two copies of this package (one hoisted for the app, one\n * nested under a dependency). Global symbol registration keeps both copies\n * reading and writing the *same* metadata slots.\n */\n\n/** `@Server(...)` options, stored on the server class. */\nexport const SNAIL_SERVER_OPTIONS = Symbol.for(\"@snail-js/api:server-options\");\n\n/** `@Api(...)` options, stored on the api class. */\nexport const SNAIL_API_OPTIONS = Symbol.for(\"@snail-js/api:api-options\");\n\n/** `@Get(...)` / `@Post(...)` / … options, stored per method. */\nexport const SNAIL_REQUEST_METHOD = Symbol.for(\"@snail-js/api:request-method\");\n\n/** `@Params()` / `@Query()` / `@Data()` parameter descriptors, stored per method. */\nexport const SNAIL_PARAMS = Symbol.for(\"@snail-js/api:params\");\n\n/** `@Header(...)` records, stored on the api class and per method. */\nexport const SNAIL_HEADERS = Symbol.for(\"@snail-js/api:headers\");\n\n/** `@UploadProgress(...)` callback, stored per method. */\nexport const SNAIL_UPLOAD_PROGRESS = Symbol.for(\"@snail-js/api:upload-progress\");\n\n/** `@DownloadProgress(...)` callback, stored per method. */\nexport const SNAIL_DOWNLOAD_PROGRESS = Symbol.for(\"@snail-js/api:download-progress\");\n\n/** `@Sse(...)` options, stored on the stream class. */\nexport const SNAIL_SSE_OPTIONS = Symbol.for(\"@snail-js/api:sse-options\");\n\n/** `@SseEvent(...)` / `@OnSseOpen()` / `@OnSseError()` handlers, stored on the stream class. */\nexport const SNAIL_SSE_HANDLERS = Symbol.for(\"@snail-js/api:sse-handlers\");\n\n/** `@WebSocket(...)` options, stored on the stream class. */\nexport const SNAIL_WS_OPTIONS = Symbol.for(\"@snail-js/api:ws-options\");\n\n/** `@OnWsOpen()` / `@OnWsMessage()` / … handlers, stored on the stream class. */\nexport const SNAIL_WS_HANDLERS = Symbol.for(\"@snail-js/api:ws-handlers\");\n\n/** `@HttpStream(...)` options, stored per method. */\nexport const SNAIL_HTTP_STREAM = Symbol.for(\"@snail-js/api:http-stream\");\n\n/**\n * Prefix reserved for third-party decorators built with\n * {@link createParamDecorator} and friends.\n *\n * Plugin authors should namespace their key, e.g.\n * `Symbol.for(\"@acme/snail-plugin:tenant\")`, so two plugins can never collide.\n */\nexport const SNAIL_CUSTOM_KEY_PREFIX = \"@snail-js/api:custom:\";\n","/**\n * A dependency-free replacement for `reflect-metadata`.\n *\n * ## Why not `reflect-metadata`?\n *\n * TypeScript 7 dropped the ability to emit `design:*` metadata: enabling\n * `emitDecoratorMetadata` is accepted but silently emits nothing (verified\n * against `tsc` 7.0.2 — the `__metadata` helper is emitted, the calls are not).\n * That removes the only capability `reflect-metadata` ever provided to this\n * library: we have never needed inferred constructor parameter types, only the\n * metadata our *own* decorators write.\n *\n * Dropping it buys three things:\n *   1. no runtime polyfill to install or import at the app entry point;\n *   2. one fewer entry in `dependencies` — axios stays the only one;\n *   3. deterministic behaviour on every runtime (browser, Node, worker, edge)\n *      because the polyfill's `Reflect.defineMetadata` is not involved at all.\n *\n * Legacy decorators (`experimentalDecorators: true`) and parameter decorators\n * remain fully supported by TypeScript 7.\n *\n * ## Storage model\n *\n * ```text\n * WeakMap<owner, Map<slot, Map<key, value>>>\n *                 │       └── the decorator's symbol key\n *                 └── CLASS_SLOT for class metadata, else the method name\n * ```\n *\n * `owner` is always a *class* (constructor function). A decorator applied to a\n * method or parameter receives the prototype, so {@link resolveOwner} maps it\n * back to the class.\n *\n * ## Decorator application order (important)\n *\n * For `@Api(\"/u\") class U { @Get() list(@Query(\"a\") a: string) {} }` the\n * runtime order is:\n *\n * ```text\n *   1. parameter decorators   (reverse index order)\n *   2. method decorators\n *   3. class decorators\n * ```\n *\n * Every writer below therefore *merges*; none of them may clobber an existing\n * value. Array-shaped metadata is appended, never replaced.\n */\n\n/** Internal slot used for class-level (non method-specific) metadata. */\nconst CLASS_SLOT = Symbol.for(\"@snail-js/api:class-slot\");\n\ntype OwnerRecord = Map<PropertyKey, Map<symbol, unknown>>;\n\nlet registry = new WeakMap<object, OwnerRecord>();\n\n/**\n * Normalise whatever a decorator receives into the class that owns the metadata.\n *\n * - class decorator → the constructor itself\n * - method / parameter decorator → `prototype.constructor`\n * - a bare prototype passed by hand → `prototype.constructor`\n */\nexport function resolveOwner(target: unknown): object {\n  if (typeof target === \"function\") return target;\n  if (target !== null && typeof target === \"object\") {\n    const ctor = (target as { constructor?: unknown }).constructor;\n    if (typeof ctor === \"function\") return ctor;\n  }\n  throw new TypeError(\n    \"[snail] metadata target must be a class, a prototype or a constructor function\"\n  );\n}\n\nfunction slotOf(propertyKey?: PropertyKey): PropertyKey {\n  return propertyKey ?? CLASS_SLOT;\n}\n\nfunction findSlotMap(owner: object, slot: PropertyKey): Map<symbol, unknown> | undefined {\n  return registry.get(owner)?.get(slot);\n}\n\nfunction ensureSlotMap(owner: object, slot: PropertyKey): Map<symbol, unknown> {\n  let record = registry.get(owner);\n  if (!record) {\n    record = new Map<PropertyKey, Map<symbol, unknown>>();\n    registry.set(owner, record);\n  }\n  let slotMap = record.get(slot);\n  if (!slotMap) {\n    slotMap = new Map<symbol, unknown>();\n    record.set(slot, slotMap);\n  }\n  return slotMap;\n}\n\n/**\n * Write metadata, replacing any value previously written for the same\n * (owner, slot, key) triple.\n */\nexport function defineMetadata(\n  key: symbol,\n  value: unknown,\n  target: unknown,\n  propertyKey?: PropertyKey\n): void {\n  ensureSlotMap(resolveOwner(target), slotOf(propertyKey)).set(key, value);\n}\n\n/** Read metadata from exactly this owner, ignoring the prototype chain. */\nexport function getOwnMetadata<T = unknown>(\n  key: symbol,\n  target: unknown,\n  propertyKey?: PropertyKey\n): T | undefined {\n  return findSlotMap(resolveOwner(target), slotOf(propertyKey))?.get(key) as T | undefined;\n}\n\n/**\n * Read metadata, walking the class prototype chain so a base api class or a base\n * server class can supply defaults to its subclasses.\n */\nexport function getMetadata<T = unknown>(\n  key: symbol,\n  target: unknown,\n  propertyKey?: PropertyKey\n): T | undefined {\n  const slot = slotOf(propertyKey);\n  let owner: object | null = resolveOwner(target);\n\n  while (owner && owner !== Function.prototype && owner !== Object.prototype) {\n    const slotMap = findSlotMap(owner, slot);\n    if (slotMap?.has(key)) return slotMap.get(key) as T;\n    owner = Object.getPrototypeOf(owner) as object | null;\n  }\n  return undefined;\n}\n\n/** `true` when {@link getMetadata} would find something. */\nexport function hasMetadata(\n  key: symbol,\n  target: unknown,\n  propertyKey?: PropertyKey\n): boolean {\n  return getMetadata(key, target, propertyKey) !== undefined;\n}\n\n/**\n * Append to array-shaped metadata, always creating a fresh array.\n *\n * Copy-on-write matters: several decorators legitimately contribute to one key\n * (four `@Query()` parameters, a class-level `@Header()` plus a method-level\n * one) and the array must never be shared with a base class.\n */\nexport function appendMetadata<T>(\n  key: symbol,\n  value: T,\n  target: unknown,\n  propertyKey?: PropertyKey\n): void {\n  const previous = getOwnMetadata<T[]>(key, target, propertyKey);\n  defineMetadata(key, previous ? [...previous, value] : [value], target, propertyKey);\n}\n\n/** Merge a record into record-shaped metadata (class-level `@Header` and friends). */\nexport function mergeMetadata<T extends object>(\n  key: symbol,\n  value: T,\n  target: unknown,\n  propertyKey?: PropertyKey\n): void {\n  const previous = getOwnMetadata<T>(key, target, propertyKey);\n  defineMetadata(key, previous ? { ...previous, ...value } : { ...value }, target, propertyKey);\n}\n\n/** Delete metadata from exactly this owner. Returns whether anything was removed. */\nexport function deleteMetadata(\n  key: symbol,\n  target: unknown,\n  propertyKey?: PropertyKey\n): boolean {\n  return findSlotMap(resolveOwner(target), slotOf(propertyKey))?.delete(key) ?? false;\n}\n\n/**\n * Collect every method name that carries metadata for `key`, walking the class\n * prototype chain from base to derived so subclasses may override.\n */\nexport function collectMethodKeys(key: symbol, target: unknown): string[] {\n  const chain: object[] = [];\n  let owner: object | null = resolveOwner(target);\n  while (owner && owner !== Function.prototype && owner !== Object.prototype) {\n    chain.unshift(owner);\n    owner = Object.getPrototypeOf(owner) as object | null;\n  }\n\n  const result: string[] = [];\n  const seen = new Set<string>();\n  for (const current of chain) {\n    const record = registry.get(current);\n    if (!record) continue;\n    for (const [slot, slotMap] of record) {\n      if (slot === CLASS_SLOT || !slotMap.has(key)) continue;\n      const name = String(slot);\n      if (seen.has(name)) continue;\n      seen.add(name);\n      result.push(name);\n    }\n  }\n  return result;\n}\n\n/**\n * Test-only escape hatch: swap the registry for a fresh `WeakMap`. Existing\n * owners become unreachable and are garbage collected.\n */\nexport function clearMetadataRegistry(): void {\n  registry = new WeakMap<object, OwnerRecord>();\n}\n","import { SnailError } from \"./base\";\n\n/** Thrown for plugin registration, dependency and uninstall failures. */\nexport class SnailPluginError extends SnailError {\n  /** Name of the plugin the failure belongs to, when known. */\n  readonly pluginName: string | undefined;\n\n  constructor(\n    message: string,\n    options: { pluginName?: string; cause?: unknown } = {}\n  ) {\n    super(message, { code: \"SNAIL_PLUGIN_ERROR\", cause: options.cause });\n    this.pluginName = options.pluginName;\n  }\n}\n","import { SnailDecoratorError } from \"../error/decorator\";\nimport { t } from \"../locale\";\nimport type { SnailParamDescriptor, SnailParamResolver } from \"../typings/args\";\nimport { appendMetadata } from \"../core/metadata\";\nimport { SNAIL_PARAMS } from \"../core/metadata.keys\";\nimport { paramResolvers, sourceLabel } from \"../core/args\";\n\n/**\n * Parameter decorators.\n *\n * Two shapes, on purpose:\n *\n * - `@Query(\"page\") page: number` — a **keyed** argument places one value.\n * - `@Query() query: SomeShape` — a **key-less** argument spreads a plain object.\n *\n * A key-less argument that is not a plain object throws, naming the method and\n * the parameter. The pre-rewrite code logged to `console.error` and then threw a\n * message that did not say which method was at fault.\n */\n\n/** A parameter decorator's accepted argument. */\nexport type ParamDecoratorInput<O = void> = string | (O & { key?: string });\n\n/** Normalise `\"key\"` / `{ key, ...options }` / `undefined`. */\nexport function normalizeParamInput<O>(\n  input: ParamDecoratorInput<O> | undefined\n): { key: string | undefined; options: O | undefined } {\n  if (input === undefined) return { key: undefined, options: undefined };\n\n  if (typeof input === \"string\") {\n    return { key: input, options: undefined };\n  }\n\n  if (input === null || typeof input !== \"object\") {\n    throw new SnailDecoratorError(t(\"error.decorator.param.untyped\", \"Source\"));\n  }\n\n  const { key, ...options } = input as { key?: string } & Record<string, unknown>;\n  return {\n    key,\n    options: Object.keys(options).length > 0 ? (options as O) : undefined\n  };\n}\n\n/**\n * Write one parameter descriptor onto the decorated method.\n *\n * Parameter decorators run *before* the method decorator and in reverse index\n * order, so this only ever appends — the descriptor list is sorted by index when\n * the arguments are applied.\n */\nexport function defineParamDescriptor(\n  source: string,\n  resolver: SnailParamResolver,\n  input: ParamDecoratorInput<any> | undefined,\n  target: unknown,\n  propertyKey: string | symbol | undefined,\n  index: number\n): void {\n  if (propertyKey === undefined) {\n    throw new SnailDecoratorError(t(\"error.decorator.param.context\", sourceLabel(source)));\n  }\n\n  const { key, options } = normalizeParamInput(input);\n\n  const descriptor: SnailParamDescriptor = {\n    source,\n    index,\n    key,\n    options,\n    resolve: resolver\n  };\n\n  appendMetadata(SNAIL_PARAMS, descriptor, target, propertyKey);\n}\n\n/**\n * Build a parameter decorator for a registered source.\n *\n * Built-in sources are `params`, `query`, `data` and `header`. A plugin can add\n * its own with `createPlugin`'s `defineParamSource`.\n */\nexport function createParamDecoratorFor<O = void>(\n  source: string\n): (input?: ParamDecoratorInput<O>) => ParameterDecorator {\n  return (input) => {\n    if (typeof input === \"string\" && input.length === 0) {\n      throw new SnailDecoratorError(t(\"error.decorator.param.untyped\", sourceLabel(source)));\n    }\n\n    return (target, propertyKey, index) => {\n      const resolver = paramResolvers[source];\n      if (!resolver) {\n        throw new SnailDecoratorError(\n          `[snail] no resolver registered for parameter source \"${source}\"`\n        );\n      }\n      defineParamDescriptor(source, resolver, input, target, propertyKey, index);\n    };\n  };\n}\n\n/**\n * Path placeholders.\n *\n * ```ts\n * @Api(\"/user\")\n * class UserApi {\n *   @Get(\"/:id/:tab\")\n *   get(@Params(\"id\") id: string, @Params(\"tab\") tab: string) {}\n *   // or, equivalently\n *   @Get(\"/:id/:tab\")\n *   get(@Params() params: { id: string; tab: string }) {}\n * }\n * ```\n */\nexport const Params = createParamDecoratorFor(\"params\");\n\n/**\n * Query string parameters.\n *\n * ```ts\n * @Get(\"/list\")\n * list(@Query(\"page\") page: number, @Query() filters: { q?: string }) {}\n * ```\n */\nexport const Query = createParamDecoratorFor(\"query\");\n\n/**\n * Request body.\n *\n * Keyed arguments merge into an object body. A key-less plain object merges too,\n * while any other value (`FormData`, `Blob`, a raw string, an array) replaces the\n * body outright so non-JSON uploads stay possible.\n */\nexport const Data = createParamDecoratorFor(\"data\");\n\n/**\n * A single request header.\n *\n * ```ts\n * @Get(\"/me\")\n * me(@HeaderValue(\"authorization\") token: string) {}\n * ```\n *\n * For *static* headers use the class/method level `@Header({ ... })` instead.\n */\nexport const HeaderValue = createParamDecoratorFor(\"header\");\n\n/** Legacy alias — the pre-rewrite library exposed the header source as `Header`. */\nexport const HeaderParam = HeaderValue;\n","import { SNAIL_CUSTOM_KEY_PREFIX } from \"../core/metadata.keys\";\nimport {\n  appendMetadata,\n  defineMetadata,\n  getMetadata,\n  getOwnMetadata\n} from \"../core/metadata\";\nimport { paramResolvers } from \"../core/args\";\nimport { SnailDecoratorError } from \"../error/decorator\";\nimport { t } from \"../locale\";\nimport type { SnailParamResolver } from \"../typings/args\";\nimport { defineParamDescriptor, type ParamDecoratorInput } from \"./args\";\n\n/**\n * Extension factories for third-party decorators.\n *\n * The library's own decorators are built from these, so anything the core can do\n * a plugin can do too.\n *\n * ## Key namespacing\n *\n * Custom keys are derived from a name you supply:\n *\n * ```ts\n * const TENANT = customMetadataKey(\"acme/tenant\");\n * ```\n *\n * Prefix your name with your package to make collisions impossible. The reserved\n * prefix `@snail-js/api:` belongs to the core.\n */\n\n/** Build a namespaced metadata key for a custom decorator. */\nexport function customMetadataKey(name: string): symbol {\n  if (typeof name !== \"string\" || name.length === 0) {\n    throw new SnailDecoratorError(\"[snail] customMetadataKey() requires a non-empty name\");\n  }\n  return Symbol.for(`${SNAIL_CUSTOM_KEY_PREFIX}${name}`);\n}\n\n/**\n * Create a **parameter** decorator.\n *\n * ```ts\n * // 1. register a source (usually inside a plugin's setup)\n * api.defineParamSource(\"tenant\", ({ ctx, value }) => {\n *   ctx.request.headers.set(\"x-tenant\", String(value));\n * });\n *\n * // 2. expose a decorator built on it\n * export const Tenant = createParamDecorator(\"tenant\");\n *\n * // 3. use it\n * @Get(\"/orders\")\n * orders(@Tenant() tenantId: string) {}\n * ```\n *\n * Pass an explicit `resolver` to skip step 1 and keep everything in one place.\n */\nexport function createParamDecorator<O = void>(\n  source: string,\n  resolver?: SnailParamResolver\n): (input?: ParamDecoratorInput<O>) => ParameterDecorator {\n  return (input) => {\n    const effective = resolver ?? paramResolvers[source];\n    if (!effective) {\n      throw new SnailDecoratorError(\n        `[snail] no resolver registered for parameter source \"${source}\"; ` +\n          `register one with createPlugin({ setup: (o, api) => api.defineParamSource(\"${source}\", fn) }) ` +\n          `or pass a resolver to createParamDecorator()`\n      );\n    }\n\n    return (target, propertyKey, index) => {\n      defineParamDescriptor(source, effective, input, target, propertyKey, index);\n    };\n  };\n}\n\n/**\n * Create a **class** decorator.\n *\n * ```ts\n * export const Entity = createClassDecorator<string>(\"acme/entity\");\n * @Entity(\"orders\") class OrderApi {}\n * ```\n *\n * @param name metadata key name\n * @param merge when `true` (the default) repeated applications keep every value\n *   in an array instead of overwriting\n */\nexport function createClassDecorator<T = unknown>(\n  name: string,\n  merge = true\n): (value: T) => ClassDecorator {\n  const key = customMetadataKey(name);\n  return (value: T) => (target) => {\n    if (merge) appendMetadata(key, value, target);\n    else defineMetadata(key, value, target);\n  };\n}\n\n/**\n * Create a **method** decorator.\n *\n * ```ts\n * export const Retry = createMethodDecorator<number>(\"acme/retry\");\n * @Get(\"/flaky\") @Retry(3) flaky() {}\n * ```\n */\nexport function createMethodDecorator<T = unknown>(\n  name: string,\n  merge = true\n): (value: T) => MethodDecorator {\n  const key = customMetadataKey(name);\n  return (value: T) => (target, propertyKey) => {\n    if (propertyKey === undefined) {\n      throw new SnailDecoratorError(\n        `[snail] createMethodDecorator(\"${name}\") must decorate a method`\n      );\n    }\n    if (merge) appendMetadata(key, value, target, propertyKey);\n    else defineMetadata(key, value, target, propertyKey);\n  };\n}\n\n/** Read metadata written by a custom method decorator. */\nexport function getMethodMetadata<T>(name: string, target: unknown, methodName: string): T | undefined {\n  return getMetadata<T>(customMetadataKey(name), target, methodName);\n}\n\n/** Read metadata written by a custom class decorator. */\nexport function getClassMetadata<T>(name: string, target: unknown): T | undefined {\n  return getMetadata<T>(customMetadataKey(name), target);\n}\n\n/** Read metadata written by a custom method decorator on exactly this class. */\nexport function getOwnMethodMetadata<T>(\n  name: string,\n  target: unknown,\n  methodName: string\n): T | undefined {\n  return getOwnMetadata<T>(customMetadataKey(name), target, methodName);\n}\n\n/**\n * Create a **property** decorator.\n *\n * Property decorators are handy for DTO classes consumed by the transform plugin:\n *\n * ```ts\n * const Alias = createPropertyDecorator<string>(\"acme/alias\");\n * class UserDto { @Alias(\"user_name\") userName!: string }\n * ```\n */\nexport function createPropertyDecorator<T = unknown>(\n  name: string\n): (value: T) => PropertyDecorator {\n  const key = customMetadataKey(name);\n  return (value: T) => (target, propertyKey) => {\n    defineMetadata(key, value, target, propertyKey);\n  };\n}\n"],"mappings":"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"}