@lakutata/nats 2.3.0 → 3.0.0-beta.0

package/dist/components/NATS.js

@@ -1,564 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NATS = exports.buildNatsClientOptions = void 0;
-const lakutata_1 = require("lakutata");
-const di_1 = require("lakutata/decorator/di");
-const nats_1 = require("nats");
-const NatsBadRequestException_1 = require("../exceptions/NatsBadRequestException");
-const NatsForbiddenException_1 = require("../exceptions/NatsForbiddenException");
-const NatsNotFoundException_1 = require("../exceptions/NatsNotFoundException");
-const NatsRequestTimeoutException_1 = require("../exceptions/NatsRequestTimeoutException");
-const NatsNoRespondersAvailableException_1 = require("../exceptions/NatsNoRespondersAvailableException");
-const NatsInternalServerException_1 = require("../exceptions/NatsInternalServerException");
-const NatsBulkException_1 = require("../exceptions/NatsBulkException");
-const ServiceEventCodec_1 = require("../lib/ServiceEventCodec");
-const MessagePackCodec_1 = require("../codecs/MessagePackCodec");
-const node_crypto_1 = require("node:crypto");
-// bulk 中转协议头(放 header,不污染 payload)
-const HDR_BULK = 'X-Lkt-Bulk'; // 能力声明:本端支持 bulk 引用中转
-const HDR_REF = 'X-Lkt-Ref'; // 标记:payload 是 Object Store 引用 {__ref}
-const buildNatsClientOptions = (options) => {
-    return {
-        class: NATS,
-        servers: options.servers,
-        codec: options.codec,
-        timeout: options.timeout,
-        token: options.token,
-        user: options.user,
-        pass: options.pass,
-        debug: options.debug,
-        maxPingOut: options.maxPingOut,
-        maxReconnectAttempts: options.maxReconnectAttempts,
-        name: options.name,
-        noEcho: options.noEcho,
-        noRandomize: options.noRandomize,
-        pingInterval: options.pingInterval,
-        reconnect: options.reconnect,
-        bulk: options.bulk,
-        bulkBucket: options.bulkBucket,
-        bulkTTL: options.bulkTTL,
-        bulkReplicas: options.bulkReplicas
-    };
-};
-exports.buildNatsClientOptions = buildNatsClientOptions;
-class NATS extends lakutata_1.Component {
-    constructor() {
-        super(...arguments);
-        /**
-         * Service event subscription map
-         * @protected
-         */
-        this.serviceEventSubscriptionMap = new Map();
-        /**
-         * 缓存对端(按 subject)是否支持 bulk 中转,从对方响应/请求的能力声明 header 学到。
-         * 用于请求侧判断对端:已知支持才发引用,未知/不支持则直传(向后兼容)。
-         * @private
-         */
-        this.#peerCapabilityCache = new Map();
-    }
-    /**
-     * NATS client instance
-     * @private
-     */
-    #conn;
-    /**
-     * bulk 连接与 Object Store(仅 bulk 启用时存在)
-     * @private
-     */
-    #bulkConn;
-    #objectStore;
-    /**
-     * 缓存对端(按 subject)是否支持 bulk 中转,从对方响应/请求的能力声明 header 学到。
-     * 用于请求侧判断对端:已知支持才发引用,未知/不支持则直传(向后兼容)。
-     * @private
-     */
-    #peerCapabilityCache;
-    /**
-     * Initializer
-     * @protected
-     */
-    async init() {
-        const connectOptions = {
-            servers: this.servers,
-            user: this.user,
-            pass: this.pass,
-            timeout: this.timeout,
-            token: this.token,
-            debug: this.debug,
-            maxPingOut: this.maxPingOut,
-            maxReconnectAttempts: this.maxReconnectAttempts,
-            name: this.name,
-            noEcho: this.noEcho,
-            noRandomize: this.noRandomize,
-            pingInterval: this.pingInterval,
-            reconnect: this.reconnect
-        };
-        this.#conn = await (0, nats_1.connect)(connectOptions);
-        if (this.bulk) {
-            try {
-                // 用同一套配置再开一条【独立】连接专供大数据,避免大对象传输堵塞 core RPC 连接;
-                // 并 get-or-create 一个 Object Store bucket 做大对象中转(短 TTL 自动清理)。
-                this.#bulkConn = await (0, nats_1.connect)({
-                    ...connectOptions,
-                    name: this.name ? `${this.name}-bulk` : undefined
-                });
-                const bucket = this.bulkBucket ?? `lkt-bulk-${this.name ?? 'default'}`;
-                // 仅在用户【显式】配置了 bulkReplicas 时才下发 replicas;默认(undefined)不发该字段,
-                // 让 server 用默认单副本。无条件发 replicas 在严格校验的 NATS server 上会被
-                // 拒绝(invalid json: unknown field "replicas"),且默认单副本显式下发本就没有收益。
-                const osOptions = {
-                    storage: nats_1.StorageType.File,
-                    ttl: (0, nats_1.nanos)(this.bulkTTL ?? 5 * 60 * 1000)
-                };
-                if (this.bulkReplicas !== undefined)
-                    osOptions.replicas = this.bulkReplicas;
-                this.#objectStore = await this.#bulkConn.jetstream().views.os(bucket, osOptions);
-            }
-            catch (e) {
-                // 优雅降级:bulk 初始化失败(JetStream 不可用 / 创建被拒 / 超时等)绝不阻塞启动。
-                // 清理半建连接并禁用 bulk(bulkEnabled 依赖 #objectStore → 自动转 false),warn 后继续,
-                // 核心 RPC/事件照常工作,仅大数据中转不可用。
-                this.#objectStore = undefined;
-                if (this.#bulkConn) {
-                    try {
-                        await this.#bulkConn.close();
-                    }
-                    catch {
-                        // 忽略关闭错误
-                    }
-                    this.#bulkConn = undefined;
-                }
-                console.warn(`[NATS] bulk 旁路初始化失败,已自动禁用 bulk(核心 RPC/事件不受影响,仅大数据中转不可用): ${e?.message ?? e}`);
-            }
-        }
-    }
-    /**
-     * Destroyer
-     * @protected
-     */
-    async destroy() {
-        await this.drainConnection(this.#conn);
-        if (this.#bulkConn)
-            await this.drainConnection(this.#bulkConn);
-    }
-    /**
-     * 优雅停机:drain 停止接收新消息、把 in-flight 处理完、flush 出站后再关闭,
-     * 这样 K8s 滚动升级/缩容时正在处理的请求不被硬切断;drain 失败兜底强制关闭。
-     * @param conn
-     * @private
-     */
-    async drainConnection(conn) {
-        try {
-            await conn.drain();
-        }
-        catch {
-            try {
-                await conn.close();
-            }
-            catch {
-                // 连接已不可用,忽略
-            }
-        }
-    }
-    /**
-     * Publishes the specified data to the specified subject.
-     * @param subject
-     * @param payload
-     */
-    publish(subject, payload) {
-        return this.#conn.publish(subject, this.codec.encode(payload));
-    }
-    /**
-     * Publishes a request with specified data in the specified subject expecting a
-     * response before timeout milliseconds. The api returns a
-     * Promise that resolves when the first response to the request is received. If
-     * there are no responders (a subscription) listening on the request subject,
-     * the request will fail as soon as the server processes it
-     * @param subject
-     * @param payload
-     * @param timeout
-     */
-    async request(subject, payload, timeout) {
-        const reqHeaders = (0, nats_1.headers)();
-        if (this.bulkEnabled)
-            reqHeaders.set(HDR_BULK, '1'); // 仅本端启用 bulk 时声明能力
-        const peerSupports = this.#peerCapabilityCache.get(subject) === true;
-        const packed = await this.packPayload(payload, peerSupports);
-        if (packed.isRef)
-            reqHeaders.set(HDR_REF, '1');
-        try {
-            const response = await this.#conn.request(subject, packed.bytes, { timeout: timeout ? timeout : 0, headers: reqHeaders });
-            // 双向协商:从响应学习对端是否支持中转
-            this.#peerCapabilityCache.set(subject, response.headers?.get(HDR_BULK) === '1');
-            // 还原响应(可能是 Object Store 引用)
-            return await this.unpackPayload(response.data, response.headers?.get(HDR_REF) === '1');
-        }
-        catch (e) {
-            if (e.code) {
-                switch (e.code.toString()) {
-                    case '400':
-                        throw new NatsBadRequestException_1.NatsBadRequestException();
-                    case '403':
-                        throw new NatsForbiddenException_1.NatsForbiddenException();
-                    case '404':
-                        throw new NatsNotFoundException_1.NatsNotFoundException();
-                    case '408':
-                    case 'TIMEOUT':
-                        throw new NatsRequestTimeoutException_1.NatsRequestTimeoutException();
-                    case '503':
-                        throw new NatsNoRespondersAvailableException_1.NatsNoRespondersAvailableException();
-                    case '500':
-                        throw new NatsInternalServerException_1.NatsInternalServerException();
-                    default:
-                        throw e;
-                }
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // 请求引用对象:服务端已取回(响应已返回),删除;失败靠 TTL 兜底
-            if (packed.objId)
-                this.deleteBulk(packed.objId).catch(() => undefined);
-        }
-    }
-    /**
-     * Subscribe expresses interest in the specified subject. The subject may
-     * have wildcards. Messages are delivered to the callback.
-     * If the subscription receives request, the callback return's value will respond to requester
-     * @param subject
-     * @param callback receives (data, subject) — `subject` is the concrete subject the message
-     *   arrived on, letting wildcard subscribers read routing tokens (e.g. an id embedded in the
-     *   subject) without the publisher having to duplicate them into the payload.
-     * @param subscribeOptions
-     */
-    subscribe(subject, callback, subscribeOptions) {
-        const subscription = this.#conn.subscribe(subject, {
-            queue: subscribeOptions?.queue,
-            max: subscribeOptions?.max
-        });
-        const handleMessage = async (msg) => {
-            try {
-                // 入站:若标记为引用,从 Object Store 取回真实 payload(对小消息/event 透明)
-                const data = await this.unpackPayload(msg.data, msg.headers?.get(HDR_REF) === '1');
-                const result = await callback(data, msg.subject);
-                // 仅当消息是请求(带 reply)时才回响应;publish/event 无 reply,跳过。
-                if (msg.reply) {
-                    const respHeaders = (0, nats_1.headers)();
-                    if (this.bulkEnabled)
-                        respHeaders.set(HDR_BULK, '1'); // 仅本端启用 bulk 时声明能力
-                    // 请求方是否支持中转 → 决定大响应能否走引用
-                    const clientSupports = msg.headers?.get(HDR_BULK) === '1';
-                    const packed = await this.packPayload(result, clientSupports);
-                    if (packed.isRef)
-                        respHeaders.set(HDR_REF, '1');
-                    msg.respond(packed.bytes, { headers: respHeaders });
-                }
-            }
-            catch (e) {
-                this.emitError(e);
-                // 若是请求且上层提供了错误响应工厂,回标准失败响应(直传 + 能力声明),避免请求方挂到超时。
-                if (msg.reply && subscribeOptions?.errorResponse) {
-                    try {
-                        const errHeaders = (0, nats_1.headers)();
-                        if (this.bulkEnabled)
-                            errHeaders.set(HDR_BULK, '1');
-                        const errorPayload = subscribeOptions.errorResponse(e);
-                        if (errorPayload !== undefined)
-                            msg.respond(this.codec.encode(errorPayload), { headers: errHeaders });
-                    }
-                    catch (encodeError) {
-                        this.emitError(encodeError);
-                    }
-                }
-            }
-        };
-        if (subscribeOptions?.iterator) {
-            setImmediate(async () => {
-                for await (const msg of subscription) {
-                    await handleMessage(msg);
-                }
-            });
-        }
-        else {
-            subscription.callback = async (err, msg) => {
-                // nats.js 在订阅级错误时以 (err, {}) 回调,此时 msg 为空对象无法处理,上报后返回。
-                if (err) {
-                    this.emitError(err);
-                    return;
-                }
-                await handleMessage(msg);
-            };
-        }
-        return subscription;
-    }
-    /**
-     * 安全地发出 error 事件:仅在存在监听器时发出。
-     * Node EventEmitter 在没有 'error' 监听器时 emit('error') 会抛出,
-     * 在异步回调里那会变成 unhandled rejection,所以这里加监听器守卫。
-     * @param error
-     * @protected
-     */
-    emitError(error) {
-        if (this.listenerCount('error') > 0)
-            this.emit('error', error);
-    }
-    /**
-     * 是否启用了 bulk 旁路(连接 + Object Store 均就绪)
-     */
-    get bulkEnabled() {
-        return !!this.bulk && !!this.#objectStore;
-    }
-    /**
-     * 走 bulk 的字节阈值 = server max_payload × 0.9(从连接 info 自动读,跟随集群配置)
-     */
-    get bulkThreshold() {
-        const maxPayload = this.#conn.info?.max_payload ?? 1024 * 1024;
-        return Math.floor(maxPayload * 0.9);
-    }
-    /**
-     * server 是否支持消息 header(从连接 info)
-     */
-    get headersSupported() {
-        return this.#conn.info?.headers === true;
-    }
-    /**
-     * 把一块字节存入 Object Store,返回 objId(供引用中转)。
-     * @param bytes
-     */
-    async putBulk(bytes) {
-        if (!this.#objectStore)
-            throw new NatsBulkException_1.NatsBulkException('bulk channel is not enabled');
-        const objId = (0, node_crypto_1.randomUUID)();
-        try {
-            await this.#objectStore.putBlob({ name: objId }, bytes);
-        }
-        catch (e) {
-            throw new NatsBulkException_1.NatsBulkException(`bulk put failed: ${e?.message ?? e}`);
-        }
-        return objId;
-    }
-    /**
-     * 从 Object Store 取回一块字节。
-     * @param objId
-     */
-    async getBulk(objId) {
-        if (!this.#objectStore)
-            throw new NatsBulkException_1.NatsBulkException('bulk channel is not enabled');
-        let data;
-        try {
-            data = await this.#objectStore.getBlob(objId);
-        }
-        catch (e) {
-            throw new NatsBulkException_1.NatsBulkException(`bulk get failed: ${e?.message ?? e}`);
-        }
-        if (data === null)
-            throw new NatsBulkException_1.NatsBulkException(`bulk object not found: ${objId}`);
-        return data;
-    }
-    /**
-     * 删除 Object Store 中的对象(用完即清,失败由 TTL 兜底)。
-     * @param objId
-     */
-    async deleteBulk(objId) {
-        if (!this.#objectStore)
-            return;
-        await this.#objectStore.delete(objId);
-    }
-    /**
-     * 返回 bulk Object Store 的运行时状态(bucket/ttl/replicas/storage/size 等);未启用 bulk 返回 undefined。
-     */
-    async bulkStatus() {
-        return this.#objectStore?.status();
-    }
-    /**
-     * 打包待发送 payload:编码后若对端支持中转且超阈值,存入 Object Store 改发小引用。
-     * @param payload
-     * @param peerSupportsBulk 对端是否支持引用中转(不支持只能直传)
-     * @private
-     */
-    async packPayload(payload, peerSupportsBulk) {
-        const bytes = this.codec.encode(payload);
-        if (peerSupportsBulk && this.bulkEnabled && bytes.length >= this.bulkThreshold) {
-            const objId = await this.putBulk(bytes);
-            return { bytes: this.codec.encode({ __ref: objId }), isRef: true, objId };
-        }
-        return { bytes, isRef: false };
-    }
-    /**
-     * 解包收到的字节:若是引用,从 Object Store 取回真实字节再解码(取回后即删,失败靠 TTL 兜底)。
-     * @param bytes
-     * @param isRef
-     * @private
-     */
-    async unpackPayload(bytes, isRef) {
-        if (isRef) {
-            const ref = this.codec.decode(bytes);
-            const realBytes = await this.getBulk(ref.__ref);
-            this.deleteBulk(ref.__ref).catch(() => undefined);
-            return this.codec.decode(realBytes);
-        }
-        return this.codec.decode(bytes);
-    }
-    /**
-     * Emit service event
-     * @param eventName
-     * @param args
-     */
-    emitServiceEvent(eventName, ...args) {
-        const eventSubject = ServiceEventCodec_1.ServiceEventCodec.formatSubject(this.app.appId, eventName);
-        this.publish(eventSubject, ServiceEventCodec_1.ServiceEventCodec.encode(args));
-        return this;
-    }
-    /**
-     * On service event
-     * @param serviceId
-     * @param eventName
-     * @param listener
-     * @param onlySingleClientReceived
-     */
-    onServiceEvent(serviceId, eventName, listener, onlySingleClientReceived = false) {
-        const eventSubject = ServiceEventCodec_1.ServiceEventCodec.formatSubject(serviceId, eventName);
-        if (!this.serviceEventSubscriptionMap.has(eventSubject))
-            this.serviceEventSubscriptionMap.set(eventSubject, new Map());
-        if (!this.serviceEventSubscriptionMap.get(eventSubject)?.has(listener)) {
-            const subscription = this.subscribe(eventSubject, (eventData) => {
-                listener(...ServiceEventCodec_1.ServiceEventCodec.decode(eventData));
-            }, onlySingleClientReceived ? { queue: eventSubject } : void (0));
-            this.serviceEventSubscriptionMap.get(eventSubject)?.set(listener, subscription);
-        }
-        return this;
-    }
-    /**
-     * Once service event
-     * @param serviceId
-     * @param eventName
-     * @param listener
-     */
-    onceServiceEvent(serviceId, eventName, listener) {
-        const eventSubject = ServiceEventCodec_1.ServiceEventCodec.formatSubject(serviceId, eventName);
-        if (!this.serviceEventSubscriptionMap.has(eventSubject))
-            this.serviceEventSubscriptionMap.set(eventSubject, new Map());
-        if (!this.serviceEventSubscriptionMap.get(eventSubject)?.has(listener)) {
-            const subscription = this.subscribe(eventSubject, (eventData) => {
-                this.serviceEventSubscriptionMap.get(eventSubject)?.delete(listener);
-                listener(...ServiceEventCodec_1.ServiceEventCodec.decode(eventData));
-            }, { max: 1 });
-            this.serviceEventSubscriptionMap.get(eventSubject)?.set(listener, subscription);
-        }
-        return this;
-    }
-    /**
-     * Off server events
-     * @param serviceId
-     * @param eventName
-     * @param listener
-     */
-    offServiceEvent(serviceId, eventName, listener) {
-        const eventSubject = ServiceEventCodec_1.ServiceEventCodec.formatSubject(serviceId, eventName);
-        if (listener) {
-            this.serviceEventSubscriptionMap.get(eventSubject)?.get(listener)?.unsubscribe();
-            this.serviceEventSubscriptionMap.get(eventSubject)?.delete(listener);
-        }
-        else {
-            this.serviceEventSubscriptionMap.get(eventSubject)?.forEach((subscription) => subscription.unsubscribe());
-            this.serviceEventSubscriptionMap.delete(eventSubject);
-        }
-        return this;
-    }
-}
-exports.NATS = NATS;
-__decorate([
-    (0, di_1.Inject)(lakutata_1.Application),
-    __metadata("design:type", lakutata_1.Application
-    /**
-     * NATS servers
-     * @protected
-     */
-    )
-], NATS.prototype, "app", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Alternatives(lakutata_1.DTO.String(), lakutata_1.DTO.Array(lakutata_1.DTO.String())).required()),
-    __metadata("design:type", Object)
-], NATS.prototype, "servers", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Object({
-        encode: lakutata_1.DTO.Function().arity(1).required(),
-        decode: lakutata_1.DTO.Function().arity(1).required()
-    }).optional().default((0, MessagePackCodec_1.MessagePackCodec)())),
-    __metadata("design:type", Object)
-], NATS.prototype, "codec", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().integer().optional()),
-    __metadata("design:type", Number)
-], NATS.prototype, "timeout", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.String().optional()),
-    __metadata("design:type", String)
-], NATS.prototype, "token", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.String().optional()),
-    __metadata("design:type", String)
-], NATS.prototype, "user", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.String().optional()),
-    __metadata("design:type", String)
-], NATS.prototype, "pass", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Boolean().optional()),
-    __metadata("design:type", Boolean)
-], NATS.prototype, "debug", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().optional()),
-    __metadata("design:type", Number)
-], NATS.prototype, "maxPingOut", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().optional().default(10)),
-    __metadata("design:type", Number)
-], NATS.prototype, "maxReconnectAttempts", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.String().optional()),
-    __metadata("design:type", String)
-], NATS.prototype, "name", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Boolean().optional()),
-    __metadata("design:type", Boolean)
-], NATS.prototype, "noEcho", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Boolean().optional()),
-    __metadata("design:type", Boolean)
-], NATS.prototype, "noRandomize", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().optional().default(1000 * 60 * 2)),
-    __metadata("design:type", Number)
-], NATS.prototype, "pingInterval", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Boolean().optional().default(true)),
-    __metadata("design:type", Boolean)
-], NATS.prototype, "reconnect", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Boolean().optional().default(true)),
-    __metadata("design:type", Boolean)
-], NATS.prototype, "bulk", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.String().optional()),
-    __metadata("design:type", String)
-], NATS.prototype, "bulkBucket", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().integer().optional().default(5 * 60 * 1000)),
-    __metadata("design:type", Number)
-], NATS.prototype, "bulkTTL", void 0);
-__decorate([
-    (0, di_1.Configurable)(lakutata_1.DTO.Number().integer().optional()),
-    __metadata("design:type", Number)
-], NATS.prototype, "bulkReplicas", void 0);

package/dist/entrypoints/SetupNatsServiceEntrypoint.d.ts

@@ -1,8 +0,0 @@
-import { ServiceEntrypoint } from 'lakutata/com/entrypoint';
-/**
- * Setup service based on NATS
- * @param natsComponentName
- * @constructor
- */
-export declare function SetupNatsServiceEntrypoint(natsComponentName: string): ServiceEntrypoint;
-//# sourceMappingURL=SetupNatsServiceEntrypoint.d.ts.map

package/dist/entrypoints/SetupNatsServiceEntrypoint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SetupNatsServiceEntrypoint.d.ts","sourceRoot":"","sources":["../../src/entrypoints/SetupNatsServiceEntrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,iBAAiB,EAEpB,MAAM,yBAAyB,CAAA;AAehC;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,iBAAiB,EAAE,MAAM,GAAG,iBAAiB,CAmBvF"}

package/dist/entrypoints/SetupNatsServiceEntrypoint.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetupNatsServiceEntrypoint = void 0;
-const entrypoint_1 = require("lakutata/com/entrypoint");
-const ServiceResponseCodec_1 = require("../lib/ServiceResponseCodec");
-/**
- * 把异常拷成可序列化的普通对象(保留 message/errno/statusCode 等自有属性)。
- * @param error
- */
-function toErrorObject(error) {
-    const errorObject = {};
-    Object.getOwnPropertyNames(error).forEach((prop) => errorObject[prop] = error[prop]);
-    return errorObject;
-}
-/**
- * Setup service based on NATS
- * @param natsComponentName
- * @constructor
- */
-function SetupNatsServiceEntrypoint(natsComponentName) {
-    return (0, entrypoint_1.BuildServiceEntrypoint)(async (module, handler) => {
-        const nats = await module.getObject(natsComponentName);
-        const appId = module.appId;
-        nats.subscribe(appId, async (incomeRequestPayload) => {
-            try {
-                return ServiceResponseCodec_1.ServiceResponseCodec.encode(await handler(new entrypoint_1.ServiceContext({
-                    data: incomeRequestPayload
-                })), false);
-            }
-            catch (e) {
-                return ServiceResponseCodec_1.ServiceResponseCodec.encode(toErrorObject(e), true);
-            }
-        }, {
-            queue: `${appId}.serviceQueue`,
-            // 入站 decode 失败 / 出站 encode 失败等发生在 handler 之外(subscribe 层)的错误,
-            // 由此工厂统一回成标准失败响应,避免请求方挂到超时。
-            errorResponse: (e) => ServiceResponseCodec_1.ServiceResponseCodec.encode(toErrorObject(e), true)
-        });
-    });
-}
-exports.SetupNatsServiceEntrypoint = SetupNatsServiceEntrypoint;

package/dist/exceptions/NatsBadRequestException.d.ts

@@ -1,7 +0,0 @@
-import { Exception } from 'lakutata';
-export declare class NatsBadRequestException extends Exception {
-    errno: string | number;
-    message: string;
-    statusCode: number;
-}
-//# sourceMappingURL=NatsBadRequestException.d.ts.map

package/dist/exceptions/NatsBadRequestException.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NatsBadRequestException.d.ts","sourceRoot":"","sources":["../../src/exceptions/NatsBadRequestException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAA;AAElC,qBAAa,uBAAwB,SAAQ,SAAS;IAC3C,KAAK,EAAE,MAAM,GAAG,MAAM,CAAuB;IAC7C,OAAO,EAAE,MAAM,CAAgB;IAC/B,UAAU,EAAE,MAAM,CAAM;CAClC"}

package/dist/exceptions/NatsBadRequestException.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NatsBadRequestException = void 0;
-const lakutata_1 = require("lakutata");
-class NatsBadRequestException extends lakutata_1.Exception {
-    constructor() {
-        super(...arguments);
-        this.errno = 'E_NATS_BAD_REQUEST';
-        this.message = 'Bad Request';
-        this.statusCode = 400;
-    }
-}
-exports.NatsBadRequestException = NatsBadRequestException;

package/dist/exceptions/NatsBulkException.d.ts

@@ -1,11 +0,0 @@
-import { Exception } from 'lakutata';
-/**
- * bulk 中转层故障(Object Store put/get 失败、引用过期取不到、bulk 未启用等)。
- * 表示"大数据通道出问题",区别于业务错误;不应自动重试(响应取不到时对侧可能已处理)。
- * message 由抛出处给出具体原因(不设默认值,以保留原因)。
- */
-export declare class NatsBulkException extends Exception {
-    errno: string | number;
-    statusCode: number;
-}
-//# sourceMappingURL=NatsBulkException.d.ts.map

package/dist/exceptions/NatsBulkException.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NatsBulkException.d.ts","sourceRoot":"","sources":["../../src/exceptions/NatsBulkException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAA;AAElC;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IACrC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAgB;IACtC,UAAU,EAAE,MAAM,CAAM;CAClC"}

package/dist/exceptions/NatsBulkException.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NatsBulkException = void 0;
-const lakutata_1 = require("lakutata");
-/**
- * bulk 中转层故障(Object Store put/get 失败、引用过期取不到、bulk 未启用等)。
- * 表示"大数据通道出问题",区别于业务错误;不应自动重试(响应取不到时对侧可能已处理)。
- * message 由抛出处给出具体原因(不设默认值,以保留原因)。
- */
-class NatsBulkException extends lakutata_1.Exception {
-    constructor() {
-        super(...arguments);
-        this.errno = 'E_NATS_BULK';
-        this.statusCode = 502;
-    }
-}
-exports.NatsBulkException = NatsBulkException;