@relaymesh/githook 0.0.7

package/dist/worker.js

@@ -0,0 +1,726 @@
+import { DefaultCodec } from "./codec.js";
+import { DriversClient, EventLogsClient, RulesClient } from "./api.js";
+import { subscriberConfigFromDriver } from "./driver_config.js";
+import { EventLogStatusFailed, EventLogStatusSuccess } from "./event_log_status.js";
+import { MetadataKeyDriver, MetadataKeyLogID, MetadataKeyRequestID } from "./metadata.js";
+import { NoRetry, normalizeRetryDecision } from "./retry.js";
+import { buildSubscriber } from "./subscriber.js";
+import { resolveOAuth2Config } from "./oauth2.js";
+export class Worker {
+    constructor(opts = {}) {
+        this.topicHandlers = new Map();
+        this.topicDrivers = new Map();
+        this.typeHandlers = new Map();
+        this.ruleHandlers = new Map();
+        this.allowedTopics = new Set();
+        this.driverSubs = new Map();
+        this.topics = [];
+        this.subscriber = opts.subscriber;
+        this.codec = opts.codec ?? new DefaultCodec();
+        this.retry = opts.retry ?? new NoRetry();
+        this.logger = opts.logger ?? defaultLogger;
+        this.middleware = opts.middleware ?? [];
+        this.listeners = opts.listeners ?? [];
+        this.clientProvider = opts.clientProvider;
+        this.endpoint = resolveEndpoint(opts.endpoint);
+        this.apiKey = resolveApiKey(opts.apiKey);
+        this.oauth2Config = resolveOAuth2Config(opts.oauth2Config);
+        this.tenantId = resolveTenantId(opts.tenantId);
+        this.defaultDriverId = (opts.defaultDriverId ?? "").trim();
+        this.validate = opts.validateTopics !== false;
+        this.semaphore = new Semaphore(normalizeConcurrency(opts.concurrency));
+        if (opts.topics) {
+            this.addTopics(opts.topics);
+        }
+        this.bindClientProvider();
+    }
+    static new(...options) {
+        const wk = new Worker();
+        for (const opt of options) {
+            opt(wk);
+        }
+        return wk;
+    }
+    HandleTopic(topic, driverOrHandler, handler) {
+        if (typeof driverOrHandler === "function") {
+            this.handleTopic(topic, driverOrHandler);
+        }
+        else {
+            this.handleTopic(topic, driverOrHandler, handler);
+        }
+    }
+    handleTopic(topic, driverOrHandler, handler) {
+        const trimmed = (topic ?? "").trim();
+        if (!trimmed) {
+            return;
+        }
+        if (this.allowedTopics.size > 0 && !this.allowedTopics.has(trimmed)) {
+            logPrintf(this.logger, "handler topic not subscribed: %s", trimmed);
+            return;
+        }
+        let driverId = "";
+        let resolvedHandler;
+        if (typeof driverOrHandler === "function") {
+            resolvedHandler = driverOrHandler;
+        }
+        else {
+            driverId = (driverOrHandler ?? "").trim();
+            resolvedHandler = handler;
+        }
+        if (!resolvedHandler) {
+            return;
+        }
+        if (!driverId) {
+            driverId = this.defaultDriverId;
+        }
+        if (!driverId && !this.subscriber) {
+            logPrintf(this.logger, "driver id required for topic: %s", trimmed);
+            return;
+        }
+        this.topicHandlers.set(trimmed, toContextHandler(resolvedHandler));
+        if (driverId) {
+            this.topicDrivers.set(trimmed, driverId);
+        }
+        this.topics.push(trimmed);
+    }
+    handleType(eventType, handler) {
+        const trimmed = (eventType ?? "").trim();
+        if (!trimmed || !handler) {
+            return;
+        }
+        this.typeHandlers.set(trimmed, toContextHandler(handler));
+    }
+    HandleType(eventType, handler) {
+        this.handleType(eventType, handler);
+    }
+    handleRule(ruleId, handler) {
+        const trimmed = (ruleId ?? "").trim();
+        if (!trimmed || !handler) {
+            return;
+        }
+        this.ruleHandlers.set(trimmed, toContextHandler(handler));
+    }
+    HandleRule(ruleId, handler) {
+        this.handleRule(ruleId, handler);
+    }
+    async run(ctx) {
+        const baseCtx = this.resolveContext(ctx);
+        await this.prepareRuleSubscriptions(baseCtx);
+        if (this.topics.length === 0) {
+            throw new Error("at least one topic is required");
+        }
+        const abortPromise = makeAbortPromise(baseCtx.signal, () => this.close());
+        if (this.subscriber) {
+            if (this.validate) {
+                await this.validateTopics(baseCtx);
+            }
+            await Promise.race([this.runWithSubscriber(baseCtx, this.subscriber, unique(this.topics)), abortPromise]);
+            return;
+        }
+        const driverTopics = this.topicsByDriver();
+        if (this.validate) {
+            await this.validateTopics(baseCtx);
+        }
+        await this.buildDriverSubscribers(baseCtx, driverTopics);
+        await Promise.race([this.runDriverSubscribers(baseCtx, driverTopics), abortPromise]);
+    }
+    Run(ctx) {
+        return this.run(ctx);
+    }
+    async close() {
+        if (this.subscriber) {
+            await this.subscriber.close();
+            return;
+        }
+        for (const sub of this.driverSubs.values()) {
+            await sub.close();
+        }
+    }
+    Close() {
+        return this.close();
+    }
+    apply(options) {
+        if (options.subscriber) {
+            this.subscriber = options.subscriber;
+        }
+        if (options.codec) {
+            this.codec = options.codec;
+        }
+        if (options.retry) {
+            this.retry = options.retry;
+        }
+        if (options.logger) {
+            this.logger = options.logger;
+        }
+        if (options.middleware) {
+            this.middleware.push(...options.middleware);
+        }
+        if (options.listeners) {
+            this.listeners.push(...options.listeners);
+        }
+        if (options.clientProvider) {
+            this.clientProvider = options.clientProvider;
+        }
+        if (options.endpoint) {
+            this.endpoint = resolveEndpoint(options.endpoint);
+        }
+        if (options.apiKey) {
+            this.apiKey = resolveApiKey(options.apiKey);
+        }
+        if (options.oauth2Config) {
+            this.oauth2Config = resolveOAuth2Config(options.oauth2Config);
+        }
+        if (options.tenantId) {
+            this.tenantId = resolveTenantId(options.tenantId);
+        }
+        if (options.defaultDriverId) {
+            this.defaultDriverId = options.defaultDriverId.trim();
+        }
+        if (options.validateTopics !== undefined) {
+            this.validate = options.validateTopics;
+        }
+        if (options.concurrency) {
+            this.semaphore = new Semaphore(normalizeConcurrency(options.concurrency));
+        }
+        if (options.topics) {
+            this.addTopics(options.topics);
+        }
+        if (options.clientProvider || options.oauth2Config || options.endpoint || options.apiKey) {
+            this.bindClientProvider();
+        }
+    }
+    Apply(options) {
+        this.apply(options);
+    }
+    addTopics(topics) {
+        for (const topic of topics) {
+            const trimmed = (topic ?? "").trim();
+            if (!trimmed) {
+                continue;
+            }
+            this.topics.push(trimmed);
+            this.allowedTopics.add(trimmed);
+        }
+    }
+    async runWithSubscriber(ctx, sub, topics) {
+        this.notifyStart(ctx);
+        try {
+            await Promise.all(topics.map((topic) => this.runTopicSubscriber(ctx, sub, topic)));
+        }
+        finally {
+            this.notifyExit(ctx);
+        }
+    }
+    async runDriverSubscribers(ctx, driverTopics) {
+        this.notifyStart(ctx);
+        try {
+            const tasks = [];
+            for (const [driverId, topics] of driverTopics.entries()) {
+                const sub = this.driverSubs.get(driverId);
+                if (!sub) {
+                    throw new Error(`subscriber not initialized for driver: ${driverId}`);
+                }
+                for (const topic of unique(topics)) {
+                    tasks.push(this.runTopicSubscriber(ctx, sub, topic));
+                }
+            }
+            await Promise.all(tasks);
+        }
+        finally {
+            this.notifyExit(ctx);
+        }
+    }
+    async runTopicSubscriber(ctx, sub, topic) {
+        await sub.start(topic, async (msg) => {
+            await this.semaphore.use(async () => {
+                const shouldNack = await this.handleMessage(ctx, topic, msg);
+                if (shouldNack && shouldRequeue(msg)) {
+                    throw new Error("message nack requested");
+                }
+            });
+        });
+    }
+    topicsByDriver() {
+        const topics = unique(this.topics);
+        if (this.topicDrivers.size === 0) {
+            if (this.defaultDriverId) {
+                return new Map([[this.defaultDriverId, topics]]);
+            }
+            throw new Error("driver id is required for topics");
+        }
+        const out = new Map();
+        for (const topic of topics) {
+            let driverId = this.topicDrivers.get(topic);
+            if (!driverId) {
+                driverId = this.defaultDriverId;
+            }
+            const trimmed = (driverId ?? "").trim();
+            if (!trimmed) {
+                throw new Error(`driver id is required for topic: ${topic}`);
+            }
+            const list = out.get(trimmed) ?? [];
+            list.push(topic);
+            out.set(trimmed, list);
+        }
+        return out;
+    }
+    async buildDriverSubscribers(ctx, driverTopics) {
+        for (const driverId of driverTopics.keys()) {
+            if (this.driverSubs.has(driverId)) {
+                continue;
+            }
+            const record = await this.driversClient().getDriverById(driverId, ctx);
+            if (!record) {
+                throw new Error(`driver not found: ${driverId}`);
+            }
+            if (!record.enabled) {
+                throw new Error(`driver is disabled: ${driverId}`);
+            }
+            const cfg = subscriberConfigFromDriver(record.name, record.configJson);
+            const sub = buildSubscriber(cfg);
+            this.driverSubs.set(driverId, sub);
+        }
+    }
+    async validateTopics(ctx) {
+        const rules = await this.rulesClient().listRules(ctx);
+        if (rules.length === 0) {
+            throw new Error("no rules available from api");
+        }
+        const allowedTopics = new Set();
+        const allowedByDriver = new Map();
+        for (const rule of rules) {
+            for (const topic of rule.emit) {
+                const trimmed = (topic ?? "").trim();
+                if (!trimmed) {
+                    continue;
+                }
+                allowedTopics.add(trimmed);
+                const driverId = (rule.driverId ?? "").trim();
+                if (!driverId) {
+                    continue;
+                }
+                if (!allowedByDriver.has(driverId)) {
+                    allowedByDriver.set(driverId, new Set());
+                }
+                allowedByDriver.get(driverId)?.add(trimmed);
+            }
+        }
+        if (allowedTopics.size === 0) {
+            throw new Error("no topics available from rules");
+        }
+        const topics = unique(this.topics);
+        if (this.subscriber) {
+            for (const topic of topics) {
+                if (!allowedTopics.has(topic)) {
+                    throw new Error(`unknown topic: ${topic}`);
+                }
+            }
+            return;
+        }
+        for (const topic of topics) {
+            let driverId = this.topicDrivers.get(topic);
+            if (!driverId) {
+                driverId = this.defaultDriverId;
+            }
+            if (!driverId) {
+                throw new Error(`driver id is required for topic: ${topic}`);
+            }
+            const allowed = allowedByDriver.get(driverId);
+            if (!allowed) {
+                throw new Error(`driver not configured on any rule: ${driverId}`);
+            }
+            if (!allowed.has(topic)) {
+                throw new Error(`topic ${topic} not configured for driver ${driverId}`);
+            }
+        }
+    }
+    async prepareRuleSubscriptions(ctx) {
+        if (this.ruleHandlers.size === 0) {
+            return;
+        }
+        const client = this.rulesClient();
+        for (const [ruleId, handler] of this.ruleHandlers.entries()) {
+            const record = await client.getRule(ruleId, ctx);
+            if (record.emit.length === 0) {
+                throw new Error(`rule ${ruleId} has no emit topic`);
+            }
+            const topic = (record.emit[0] ?? "").trim();
+            if (!topic) {
+                throw new Error(`rule ${ruleId} emit topic empty`);
+            }
+            const driverId = (record.driverId ?? "").trim();
+            if (!driverId) {
+                throw new Error(`rule ${ruleId} driver_id is required`);
+            }
+            if (this.topicHandlers.has(topic)) {
+                logPrintf(this.logger, "overwriting handler for topic=%s due to rule=%s", topic, ruleId);
+            }
+            this.topicHandlers.set(topic, handler);
+            this.topicDrivers.set(topic, driverId);
+            this.topics.push(topic);
+        }
+    }
+    async handleMessage(ctx, topic, msg) {
+        const logId = msg.metadata?.[MetadataKeyLogID] ?? "";
+        let event;
+        try {
+            event = this.codec.decode(topic, msg);
+        }
+        catch (err) {
+            const error = normalizeError(err);
+            logPrintf(this.logger, "decode failed: %s", error.message);
+            await this.updateEventLogStatus(ctx, logId, EventLogStatusFailed, error);
+            this.notifyError(ctx, undefined, error);
+            const decision = normalizeRetryDecision(callRetryPolicy(this.retry, ctx, undefined, error));
+            return decision.retry || decision.nack;
+        }
+        const eventCtx = this.buildContext(ctx, topic, msg);
+        if (this.clientProvider) {
+            try {
+                event.client = await resolveClientProvider(this.clientProvider)(eventCtx, event);
+            }
+            catch (err) {
+                const error = normalizeError(err);
+                logPrintf(this.logger, "client init failed: %s", error.message);
+                await this.updateEventLogStatus(eventCtx, logId, EventLogStatusFailed, error);
+                this.notifyError(eventCtx, event, error);
+                const decision = normalizeRetryDecision(callRetryPolicy(this.retry, eventCtx, event, error));
+                return decision.retry || decision.nack;
+            }
+        }
+        const reqId = event.metadata[MetadataKeyRequestID];
+        if (reqId) {
+            logPrintf(this.logger, "request_id=%s topic=%s provider=%s type=%s", reqId, event.topic, event.provider, event.type);
+        }
+        this.notifyMessageStart(eventCtx, event);
+        const handler = this.topicHandlers.get(topic) ?? this.typeHandlers.get(event.type);
+        if (!handler) {
+            logPrintf(this.logger, "no handler for topic=%s type=%s", topic, event.type);
+            this.notifyMessageFinish(eventCtx, event, undefined);
+            await this.updateEventLogStatus(eventCtx, logId, EventLogStatusSuccess);
+            return false;
+        }
+        const wrapped = this.wrap(handler);
+        try {
+            await wrapped(eventCtx, event);
+            this.notifyMessageFinish(eventCtx, event, undefined);
+            await this.updateEventLogStatus(eventCtx, logId, EventLogStatusSuccess);
+            return false;
+        }
+        catch (err) {
+            const error = normalizeError(err);
+            this.notifyMessageFinish(eventCtx, event, error);
+            this.notifyError(eventCtx, event, error);
+            await this.updateEventLogStatus(eventCtx, logId, EventLogStatusFailed, error);
+            const decision = normalizeRetryDecision(callRetryPolicy(this.retry, eventCtx, event, error));
+            return decision.retry || decision.nack;
+        }
+    }
+    wrap(handler) {
+        let wrapped = handler;
+        for (let i = this.middleware.length - 1; i >= 0; i -= 1) {
+            wrapped = this.middleware[i](wrapped);
+        }
+        return wrapped;
+    }
+    buildContext(base, topic, msg) {
+        return {
+            tenantId: base.tenantId,
+            signal: base.signal,
+            topic,
+            requestId: msg.metadata?.[MetadataKeyRequestID],
+            logId: msg.metadata?.[MetadataKeyLogID],
+        };
+    }
+    resolveContext(ctx) {
+        if (!ctx) {
+            return { tenantId: this.tenantId };
+        }
+        if (isAbortSignal(ctx)) {
+            return { tenantId: this.tenantId, signal: ctx };
+        }
+        return { tenantId: ctx.tenantId ?? this.tenantId, signal: ctx.signal };
+    }
+    notifyStart(ctx) {
+        for (const listener of this.listeners) {
+            listener.onStart?.(ctx);
+            listener.OnStart?.(ctx);
+        }
+    }
+    notifyExit(ctx) {
+        for (const listener of this.listeners) {
+            listener.onExit?.(ctx);
+            listener.OnExit?.(ctx);
+        }
+    }
+    notifyMessageStart(ctx, evt) {
+        for (const listener of this.listeners) {
+            listener.onMessageStart?.(ctx, evt);
+            listener.OnMessageStart?.(ctx, evt);
+        }
+    }
+    notifyMessageFinish(ctx, evt, err) {
+        for (const listener of this.listeners) {
+            listener.onMessageFinish?.(ctx, evt, err);
+            listener.OnMessageFinish?.(ctx, evt, err);
+        }
+    }
+    notifyError(ctx, evt, err) {
+        for (const listener of this.listeners) {
+            listener.onError?.(ctx, evt, err);
+            listener.OnError?.(ctx, evt, err);
+        }
+    }
+    driversClient() {
+        return new DriversClient(this.apiClientOptions());
+    }
+    rulesClient() {
+        return new RulesClient(this.apiClientOptions());
+    }
+    eventLogsClient() {
+        return new EventLogsClient(this.apiClientOptions());
+    }
+    apiClientOptions() {
+        return {
+            baseUrl: this.endpoint,
+            apiKey: this.apiKey,
+            oauth2Config: this.oauth2Config,
+            tenantId: this.tenantId,
+        };
+    }
+    async updateEventLogStatus(ctx, logId, status, err) {
+        if (!logId) {
+            return;
+        }
+        try {
+            await this.eventLogsClient().updateStatus(logId, status, err?.message, ctx);
+        }
+        catch (updateErr) {
+            const error = normalizeError(updateErr);
+            logPrintf(this.logger, "event log update failed: %s", error.message);
+        }
+    }
+    bindClientProvider() {
+        if (!this.clientProvider) {
+            return;
+        }
+        const provider = this.clientProvider;
+        const opts = this.apiClientOptions();
+        if (provider.bindAPIClient) {
+            provider.bindAPIClient(opts);
+        }
+        else if (provider.BindAPIClient) {
+            provider.BindAPIClient(opts);
+        }
+    }
+}
+export function New(...options) {
+    return Worker.new(...options);
+}
+export function WithSubscriber(subscriber) {
+    return (wk) => wk.apply({ subscriber });
+}
+export function WithTopics(...topics) {
+    return (wk) => wk.apply({ topics });
+}
+export function WithConcurrency(concurrency) {
+    return (wk) => wk.apply({ concurrency });
+}
+export function WithCodec(codec) {
+    return (wk) => wk.apply({ codec });
+}
+export function WithMiddleware(...middleware) {
+    return (wk) => wk.apply({ middleware });
+}
+export function WithRetry(retry) {
+    return (wk) => wk.apply({ retry });
+}
+export function WithLogger(logger) {
+    return (wk) => wk.apply({ logger });
+}
+export function WithClientProvider(clientProvider) {
+    return (wk) => wk.apply({ clientProvider });
+}
+export function WithListener(listener) {
+    return (wk) => wk.apply({ listeners: [listener] });
+}
+export function WithEndpoint(endpoint) {
+    return (wk) => wk.apply({ endpoint });
+}
+export function WithAPIKey(apiKey) {
+    return (wk) => wk.apply({ apiKey });
+}
+export function WithOAuth2Config(oauth2Config) {
+    return (wk) => wk.apply({ oauth2Config });
+}
+export function WithTenant(tenantId) {
+    return (wk) => wk.apply({ tenantId });
+}
+export function WithDefaultDriver(driverId) {
+    return (wk) => wk.apply({ defaultDriverId: driverId });
+}
+export function WithValidateTopics(validate) {
+    return (wk) => wk.apply({ validateTopics: validate });
+}
+const defaultLogger = {
+    printf(format, ...args) {
+        if (args.length === 0) {
+            console.log(`githook/worker ${format}`);
+            return;
+        }
+        console.log(`githook/worker ${format}`, ...args);
+    },
+};
+function resolveEndpoint(explicit) {
+    const trimmed = (explicit ?? "").trim();
+    if (trimmed) {
+        return trimmed.replace(/\/+$/, "");
+    }
+    const envEndpoint = envValue("GITHOOK_ENDPOINT");
+    if (envEndpoint) {
+        return envEndpoint;
+    }
+    const envBase = envValue("GITHOOK_API_BASE_URL");
+    if (envBase) {
+        return envBase;
+    }
+    return "http://localhost:8080";
+}
+function resolveApiKey(explicit) {
+    const trimmed = (explicit ?? "").trim();
+    if (trimmed) {
+        return trimmed;
+    }
+    return envValue("GITHOOK_API_KEY");
+}
+function resolveTenantId(explicit) {
+    const trimmed = (explicit ?? "").trim();
+    if (trimmed) {
+        return trimmed;
+    }
+    return envValue("GITHOOK_TENANT_ID");
+}
+function envValue(key) {
+    return (process.env[key] ?? "").trim();
+}
+function normalizeConcurrency(value) {
+    if (!value || value < 1) {
+        return 1;
+    }
+    return Math.floor(value);
+}
+function unique(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+function normalizeError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    return new Error(String(err));
+}
+function callRetryPolicy(policy, ctx, evt, err) {
+    if (policy.OnError) {
+        return policy.OnError(ctx, evt, err);
+    }
+    if (policy.onError) {
+        return policy.onError(ctx, evt, err);
+    }
+    return { retry: false, nack: true };
+}
+function logPrintf(logger, format, ...args) {
+    if (logger.Printf) {
+        logger.Printf(format, ...args);
+        return;
+    }
+    if (logger.printf) {
+        logger.printf(format, ...args);
+        return;
+    }
+    if (args.length === 0) {
+        console.log(`githook/worker ${format}`);
+        return;
+    }
+    console.log(`githook/worker ${format}`, ...args);
+}
+function resolveClientProvider(provider) {
+    if (provider.client) {
+        return async (ctx, evt) => provider.client?.(ctx, evt);
+    }
+    if (provider.Client) {
+        return async (ctx, evt) => provider.Client?.(ctx, evt);
+    }
+    return async () => undefined;
+}
+function toContextHandler(handler) {
+    if (handler.length >= 2) {
+        return handler;
+    }
+    return (_ctx, event) => handler(event);
+}
+function shouldRequeue(msg) {
+    const driver = (msg.metadata?.[MetadataKeyDriver] ?? "").toLowerCase();
+    return driver === "amqp";
+}
+function isAbortSignal(value) {
+    return !!value && typeof value.aborted === "boolean";
+}
+function makeAbortPromise(signal, onAbort) {
+    if (!signal) {
+        return new Promise(() => { });
+    }
+    if (signal.aborted) {
+        onAbort();
+        return Promise.reject(new Error("aborted"));
+    }
+    return new Promise((_, reject) => {
+        signal.addEventListener("abort", () => {
+            onAbort();
+            reject(new Error("aborted"));
+        }, { once: true });
+    });
+}
+class Semaphore {
+    constructor(size) {
+        this.size = size;
+        this.queue = [];
+        this.available = size;
+    }
+    async use(task) {
+        const release = await this.acquire();
+        try {
+            await task();
+        }
+        finally {
+            release();
+        }
+    }
+    acquire() {
+        return new Promise((resolve) => {
+            const attempt = () => {
+                if (this.available > 0) {
+                    this.available -= 1;
+                    resolve(() => {
+                        this.available += 1;
+                        const next = this.queue.shift();
+                        if (next) {
+                            next();
+                        }
+                    });
+                    return;
+                }
+                this.queue.push(attempt);
+            };
+            attempt();
+        });
+    }
+}
+//# sourceMappingURL=worker.js.map