@zintrust/core 0.4.62 → 0.4.64

package/src/tools/broadcast/Broadcast.js

@@ -1,9 +1,228 @@
+import { isArray, isNonEmptyString, isObject } from '../../helper/index.js';
 import { InMemoryDriver } from './drivers/InMemory.js';
 import { PusherDriver } from './drivers/Pusher.js';
 import { RedisDriver } from './drivers/Redis.js';
 import { RedisHttpsDriver } from './drivers/RedisHttps.js';
 import broadcastConfig from '../../config/broadcast.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const INTERNAL_SOCKET_SECRET_HEADER = 'x-zintrust-socket-secret';
+const pickFirstNonEmpty = (...values) => {
+    for (const value of values) {
+        if (value.trim() !== '') {
+            return value.trim();
+        }
+    }
+    return '';
+};
+const normalizeChannelScope = (value) => {
+    if (!isNonEmptyString(value)) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'public' ||
+        normalized === 'private' ||
+        normalized === 'presence' ||
+        normalized === 'persistent') {
+        return normalized;
+    }
+    return undefined;
+};
+const getQualifiedChannelScope = (channel) => {
+    if (channel.startsWith('private-'))
+        return 'private';
+    if (channel.startsWith('presence-'))
+        return 'presence';
+    if (channel.startsWith('persistent-'))
+        return 'persistent';
+    return undefined;
+};
+const applyChannelScope = (channel, scope) => {
+    const normalizedChannel = channel.trim();
+    const existingScope = getQualifiedChannelScope(normalizedChannel);
+    if (existingScope !== undefined) {
+        if (scope !== undefined && scope !== existingScope) {
+            throw ErrorFactory.createValidationError(`Broadcast channel scope ${scope} conflicts with fully-qualified channel ${normalizedChannel}.`);
+        }
+        return normalizedChannel;
+    }
+    if (scope === undefined || scope === 'public') {
+        return normalizedChannel;
+    }
+    return `${scope}-${normalizedChannel}`;
+};
+const normalizeChannels = (input) => {
+    const scope = normalizeChannelScope(input.channelScope ?? input.scope);
+    if (isArray(input.channels)) {
+        return input.channels
+            .filter(isNonEmptyString)
+            .map((channel) => applyChannelScope(channel, scope));
+    }
+    if (isNonEmptyString(input.channel)) {
+        return [applyChannelScope(input.channel, scope)];
+    }
+    return [];
+};
+const appendUnique = (values, nextValue) => {
+    if (nextValue !== '' && !values.includes(nextValue)) {
+        values.push(nextValue);
+    }
+};
+const toAbsoluteBaseUrl = (value) => {
+    const trimmed = value.trim();
+    if (trimmed === '' || trimmed.startsWith('/')) {
+        return '';
+    }
+    try {
+        return new URL(trimmed).toString();
+    }
+    catch {
+        try {
+            return new URL(`http://${trimmed}`).toString();
+        }
+        catch {
+            return '';
+        }
+    }
+};
+const getLoopbackAlternativeBaseUrl = (value) => {
+    try {
+        const parsed = new URL(value);
+        if (parsed.hostname === '127.0.0.1') {
+            parsed.hostname = 'localhost';
+            return parsed.toString();
+        }
+        if (parsed.hostname === 'localhost' ||
+            parsed.hostname === '[::1]' ||
+            parsed.hostname === '::1') {
+            parsed.hostname = '127.0.0.1';
+            return parsed.toString();
+        }
+    }
+    catch {
+        return '';
+    }
+    return '';
+};
+const getInternalPublishConfig = () => {
+    const baseUrls = [];
+    appendUnique(baseUrls, toAbsoluteBaseUrl(Env.get('BROADCAST_INTERNAL_URL', '')));
+    appendUnique(baseUrls, toAbsoluteBaseUrl(Env.get('APP_URL', '')));
+    appendUnique(baseUrls, toAbsoluteBaseUrl(Env.get('BASE_URL', Env.BASE_URL ?? '')));
+    const resolvedBaseUrls = [];
+    for (const baseUrl of baseUrls) {
+        appendUnique(resolvedBaseUrls, baseUrl);
+        appendUnique(resolvedBaseUrls, getLoopbackAlternativeBaseUrl(baseUrl));
+    }
+    const appId = pickFirstNonEmpty(Env.get('PUSHER_APP_ID', ''), Env.get('BROADCAST_APP_ID', '')) || 'internal';
+    const secret = pickFirstNonEmpty(Env.get('BROADCAST_SECRET', ''), Env.get('PUSHER_APP_SECRET', ''), Env.get('BROADCAST_APP_SECRET', ''));
+    return Object.freeze({
+        endpoints: resolvedBaseUrls.map((baseUrl) => new URL(`/apps/${encodeURIComponent(appId)}/events`, baseUrl).toString()),
+        appId,
+        secret,
+    });
+};
+const parseJsonResponseSafe = async (response) => {
+    const raw = await response.text();
+    if (raw.trim() === '') {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return { raw };
+    }
+};
+const getDeliveries = (payload) => {
+    if (!isObject(payload)) {
+        return undefined;
+    }
+    const deliveries = payload['deliveries'];
+    return typeof deliveries === 'number' && Number.isFinite(deliveries) ? deliveries : undefined;
+};
+const describeError = (error) => {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+        };
+    }
+    return String(error);
+};
+const logTransportFallback = (transport, details) => {
+    Logger.warn('Broadcast publish transport failed; falling back.', {
+        transport,
+        ...details,
+    });
+};
+const requestInternalPublishEndpoint = async (endpoint, secret, payload) => {
+    try {
+        const response = await globalThis.fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(secret === ''
+                    ? {}
+                    : {
+                        [INTERNAL_SOCKET_SECRET_HEADER]: secret,
+                        authorization: `Bearer ${secret}`,
+                    }),
+            },
+            body: JSON.stringify(payload),
+        });
+        const responseBody = await parseJsonResponseSafe(response);
+        if (!response.ok) {
+            const error = ErrorFactory.createTryCatchError(`Internal socket publish request failed (${response.status})`, {
+                status: response.status,
+                endpoint,
+                body: responseBody,
+            });
+            logTransportFallback('internal-http', {
+                endpoint,
+                status: response.status,
+                body: responseBody,
+            });
+            return { result: null, error };
+        }
+        const resolvedChannels = isObject(responseBody) && isArray(responseBody['channels'])
+            ? responseBody['channels'].filter(isNonEmptyString).map((channel) => channel.trim())
+            : payload.channels;
+        const resolvedEvent = isObject(responseBody) && isNonEmptyString(responseBody['event'])
+            ? responseBody['event'].trim()
+            : payload.event;
+        return {
+            result: {
+                ok: true,
+                transport: 'internal-http',
+                channels: resolvedChannels,
+                event: resolvedEvent,
+                deliveries: getDeliveries(responseBody),
+                endpoint,
+                result: responseBody,
+            },
+        };
+    }
+    catch (error) {
+        logTransportFallback('internal-http', {
+            endpoint,
+            error: describeError(error),
+        });
+        return { result: null, error };
+    }
+};
+const tryInternalPublishEndpoints = async (endpoints, secret, payload, index = 0, lastError) => {
+    const endpoint = endpoints[index];
+    if (endpoint === undefined) {
+        return { result: null, error: lastError };
+    }
+    const attempt = await requestInternalPublishEndpoint(endpoint, secret, payload);
+    if (attempt.result !== null) {
+        return attempt;
+    }
+    return tryInternalPublishEndpoints(endpoints, secret, payload, index + 1, attempt.error ?? lastError);
+};
 const resolveBroadcasterConfig = async (name) => {
     const selection = (name ?? broadcastConfig.getDriverName()).toString().trim().toLowerCase();
     try {
@@ -44,39 +263,177 @@ const sendWithConfig = async (config, channel, event, data) => {
     }
     throw ErrorFactory.createConfigError(`Broadcast driver not implemented: ${driverName}`);
 };
+const normalizeDelivery = (value) => {
+    if (value === 'socket' || value === 'driver') {
+        return value;
+    }
+    return 'auto';
+};
+const normalizePublishInput = (input) => {
+    let event = '';
+    if (isNonEmptyString(input.event)) {
+        event = input.event.trim();
+    }
+    else if (isNonEmptyString(input.name)) {
+        event = input.name.trim();
+    }
+    const channels = normalizeChannels(input);
+    if (event === '' || channels.length === 0) {
+        throw ErrorFactory.createValidationError('Broadcast.publish requires event/name and channel/channels.');
+    }
+    return {
+        channels,
+        event,
+        data: input.data ?? {},
+        ...(isNonEmptyString(input.socketId) ? { socketId: input.socketId.trim() } : {}),
+        delivery: normalizeDelivery(input.delivery),
+        ...(isNonEmptyString(input.broadcaster) ? { broadcaster: input.broadcaster.trim() } : {}),
+        ...(input.request === undefined ? {} : { request: input.request }),
+        ...(input.user === undefined ? {} : { user: input.user }),
+    };
+};
+const tryPublishViaSocket = async (input) => {
+    try {
+        const socketModule = (await import('@zintrust/socket'));
+        const socketResult = await socketModule.publishSocketEventFromServer({
+            channels: input.channels,
+            event: input.event,
+            data: input.data,
+            socketId: input.socketId,
+            request: input.request,
+            user: input.user,
+        });
+        return {
+            result: {
+                ok: true,
+                transport: 'socket',
+                channels: socketResult.channels,
+                event: socketResult.event,
+                deliveries: socketResult.deliveries,
+                result: socketResult,
+            },
+        };
+    }
+    catch (error) {
+        return { result: null, error };
+    }
+};
+const tryPublishViaInternalHttp = async (input) => {
+    const config = getInternalPublishConfig();
+    if (config.endpoints.length === 0 || typeof globalThis.fetch !== 'function') {
+        return { result: null };
+    }
+    const payload = {
+        channels: input.channels,
+        event: input.event,
+        data: input.data,
+        ...(input.socketId === undefined ? {} : { socket_id: input.socketId }),
+    };
+    return tryInternalPublishEndpoints(config.endpoints, config.secret, payload);
+};
+const publishWithConfig = async (config, broadcasterName, input) => {
+    const results = await Promise.all(input.channels.map(async (channel) => sendWithConfig(config, channel, input.event, input.data)));
+    return {
+        ok: true,
+        transport: 'driver',
+        channels: input.channels,
+        event: input.event,
+        driver: config.driver,
+        ...(broadcasterName === undefined ? {} : { broadcaster: broadcasterName }),
+        ...(results.length === 1 ? { result: results[0] } : { results }),
+    };
+};
+const publishInternal = async (input) => {
+    const normalized = normalizePublishInput(input);
+    const attemptedTransports = [];
+    let lastTransportError;
+    if (normalized.delivery !== 'driver') {
+        attemptedTransports.push('internal-http');
+        const internalHttpResult = await tryPublishViaInternalHttp(normalized);
+        if (internalHttpResult.result !== null) {
+            return { ...internalHttpResult.result, attemptedTransports };
+        }
+        if (internalHttpResult.error !== undefined) {
+            lastTransportError = internalHttpResult.error;
+        }
+        attemptedTransports.push('socket');
+        const socketResult = await tryPublishViaSocket(normalized);
+        if (socketResult.result !== null) {
+            return { ...socketResult.result, attemptedTransports };
+        }
+        if (socketResult.error !== undefined) {
+            lastTransportError = socketResult.error;
+            logTransportFallback('socket', {
+                error: describeError(socketResult.error),
+            });
+        }
+    }
+    if (normalized.delivery === 'socket') {
+        if (lastTransportError instanceof Error) {
+            throw lastTransportError;
+        }
+        throw ErrorFactory.createConfigError('Socket publish delivery is not available.');
+    }
+    attemptedTransports.push('driver');
+    const config = await resolveBroadcasterConfig(normalized.broadcaster);
+    return {
+        ...(await publishWithConfig(config, normalized.broadcaster, normalized)),
+        attemptedTransports,
+    };
+};
+const publishLaterInternal = async (input, options = {}) => {
+    const normalized = normalizePublishInput(input);
+    const { queueName = 'broadcasts', timestamp = Date.now() } = options;
+    const { Queue } = await import('../queue/Queue.js');
+    return Queue.enqueue(queueName, {
+        type: 'broadcast',
+        channel: normalized.channels[0],
+        channels: normalized.channels,
+        event: normalized.event,
+        data: normalized.data,
+        ...(normalized.socketId === undefined ? {} : { socketId: normalized.socketId }),
+        ...(normalized.broadcaster === undefined ? {} : { broadcaster: normalized.broadcaster }),
+        delivery: normalized.delivery,
+        timestamp,
+        attempts: 0,
+    });
+};
 export const Broadcast = Object.freeze({
+    async publish(input) {
+        return publishInternal(input);
+    },
     async send(channel, event, data) {
-        const config = await resolveBroadcasterConfig();
-        return sendWithConfig(config, channel, event, data);
+        const result = await publishInternal({ channel, event, data });
+        if (result.transport === 'driver') {
+            return result.result ?? result.results ?? result;
+        }
+        return result.result ?? result;
     },
     // Alias for send() - explicit intent for immediate broadcast
     async broadcastNow(channel, event, data) {
         return this.send(channel, event, data);
     },
+    async publishLater(input, options = {}) {
+        return publishLaterInternal(input, options);
+    },
     // Queue broadcast for async processing
     async BroadcastLater(channel, event, data, options = {}) {
-        const { queueName = 'broadcasts', timestamp = Date.now() } = options;
-        const { Queue } = await import('../queue/Queue.js');
-        const messageId = await Queue.enqueue(queueName, {
-            type: 'broadcast',
-            channel,
-            event,
-            data,
-            timestamp,
-            attempts: 0,
-        });
-        return messageId;
+        return publishLaterInternal({ channel, event, data }, options);
     },
     queue(queueName) {
         return Object.freeze({
-            BroadcastLater: async (channel, event, data, options = {}) => Broadcast.BroadcastLater(channel, event, data, { ...options, queueName }),
+            publishLater: async (input, options = {}) => publishLaterInternal(input, { ...options, queueName }),
+            BroadcastLater: async (channel, event, data, options = {}) => publishLaterInternal({ channel, event, data }, { ...options, queueName }),
         });
     },
     broadcaster(name) {
         return Object.freeze({
             send: async (channel, event, data) => {
-                const config = await resolveBroadcasterConfig(name);
-                return sendWithConfig(config, channel, event, data);
+                const result = await publishWithConfig(await resolveBroadcasterConfig(name), name, normalizePublishInput({ channel, event, data, delivery: 'driver', broadcaster: name }));
+                return result.result ?? result.results ?? result;
+            },
+            publish: async (input) => {
+                return publishWithConfig(await resolveBroadcasterConfig(name), name, normalizePublishInput({ ...input, delivery: 'driver', broadcaster: name }));
             },
         });
     },

package/src/tools/broadcast/index.d.ts

@@ -1,4 +1,5 @@
 export { Broadcast } from './Broadcast';
+export type { BroadcastPublishInput, BroadcastPublishResult } from './Broadcast';
 export { BroadcastRegistry } from './BroadcastRegistry';
 export { registerBroadcastersFromRuntimeConfig } from './BroadcastRuntimeRegistration';
 export { BaseDriver } from './drivers/BaseDriver';

package/src/tools/broadcast/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,qCAAqC,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,YAAY,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,qCAAqC,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC"}

package/src/zintrust.comon.d.ts

@@ -0,0 +1,11 @@
+import '../packages/db-d1/src/register.js';
+import '../packages/db-mysql/src/register.js';
+import '../packages/db-postgres/src/register.js';
+import '../packages/db-sqlite/src/register.js';
+import '../packages/db-sqlserver/src/register.js';
+import '../packages/mail-sendgrid/src/register.js';
+import '../packages/mail-smtp/src/register.js';
+import '@zintrust/queue-monitor';
+import '../packages/queue-redis/src/register.js';
+import '../packages/workers/src/register.js';
+//# sourceMappingURL=zintrust.comon.d.ts.map

package/src/zintrust.comon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zintrust.comon.d.ts","sourceRoot":"","sources":["../../src/zintrust.comon.ts"],"names":[],"mappings":"AAQA,OAAO,mCAAmC,CAAC;AAC3C,OAAO,sCAAsC,CAAC;AAC9C,OAAO,yCAAyC,CAAC;AACjD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,0CAA0C,CAAC;AAClD,OAAO,2CAA2C,CAAC;AACnD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,wCAAwC,CAAC;AAChD,OAAO,yCAAyC,CAAC;AACjD,OAAO,qCAAqC,CAAC"}

package/src/zintrust.comon.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-restricted-imports */
+// /**
+//  * ZinTrust comon plugin auto-imports
+//  *
+//  * This file is managed by `zin plugin install` and contains side-effect
+//  * imports that register optional adapters/drivers into core registries.
+//  */
+import '../packages/db-d1/src/register.js';
+import '../packages/db-mysql/src/register.js';
+import '../packages/db-postgres/src/register.js';
+import '../packages/db-sqlite/src/register.js';
+import '../packages/db-sqlserver/src/register.js';
+import '../packages/mail-sendgrid/src/register.js';
+import '../packages/mail-smtp/src/register.js';
+import '@zintrust/queue-monitor';
+import '../packages/queue-redis/src/register.js';
+import '../packages/workers/src/register.js';

package/src/zintrust.plugins.d.ts

@@ -1,8 +1,12 @@
 /**
- * Auto-generated fallback module.
- * This file is created by scripts/ensure-worker-plugins.mjs when missing.
- * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
+ * ZinTrust plugin auto-imports
+ *
+ * In real projects, this file is managed by `zin plugin install` and contains
+ * side-effect imports (e.g. `@zintrust/db-sqlite/register`) that register
+ * optional adapters/drivers into core registries.
+ *
  */
+export type {};
 export declare const __zintrustGeneratedPluginStub = "zintrust.plugins.ts";
 declare const _default: {};
 export default _default;

package/src/zintrust.plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zintrust.plugins.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;;AACnE,wBAAkB"}
+{"version":3,"file":"zintrust.plugins.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,YAAY,EAAE,CAAC;AAgBf,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;;AACnE,wBAAkB"}

package/src/zintrust.plugins.js

@@ -1,7 +1,13 @@
 /**
- * Auto-generated fallback module.
- * This file is created by scripts/ensure-worker-plugins.mjs when missing.
- * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
+ * ZinTrust plugin auto-imports
+ *
+ * In real projects, this file is managed by `zin plugin install` and contains
+ * side-effect imports (e.g. `@zintrust/db-sqlite/register`) that register
+ * optional adapters/drivers into core registries.
+ *
  */
+import * as SystemDebuggerRuntime from './runtime/plugins/system-debugger-runtime.js';
+globalThis.__zintrust_system_debugger_plugin_requested__ = true;
+globalThis.__zintrust_system_debugger_runtime__ = SystemDebuggerRuntime;
 export const __zintrustGeneratedPluginStub = 'zintrust.plugins.ts';
 export default {};

package/src/zintrust.plugins.wg.d.ts

@@ -3,6 +3,7 @@
  * This file is created by scripts/ensure-worker-plugins.mjs when missing.
  * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
  */
+export type {};
 export declare const __zintrustGeneratedPluginStub = "zintrust.plugins.wg.ts";
 declare const _default: {};
 export default _default;

package/src/zintrust.plugins.wg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zintrust.plugins.wg.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.wg.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,6BAA6B,2BAA2B,CAAC;;AACtE,wBAAkB"}
+{"version":3,"file":"zintrust.plugins.wg.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.wg.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,YAAY,EAAE,CAAC;AAgBf,eAAO,MAAM,6BAA6B,2BAA2B,CAAC;;AACtE,wBAAkB"}

package/src/zintrust.plugins.wg.js

@@ -3,5 +3,8 @@
  * This file is created by scripts/ensure-worker-plugins.mjs when missing.
  * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
  */
+import * as SystemDebuggerRuntime from './runtime/plugins/system-debugger-runtime.js';
+globalThis.__zintrust_system_debugger_plugin_requested__ = true;
+globalThis.__zintrust_system_debugger_runtime__ = SystemDebuggerRuntime;
 export const __zintrustGeneratedPluginStub = 'zintrust.plugins.wg.ts';
 export default {};