@zintrust/core 0.4.17 → 0.4.18

package/src/tools/broadcast/BroadcastRegistry.ts

@@ -1,38 +0,0 @@
-import type { KnownBroadcastDriverConfig } from '@config/type';
-
-import { ErrorFactory } from '@exceptions/ZintrustError';
-
-const registry = new Map<string, KnownBroadcastDriverConfig>();
-
-const normalize = (value: string): string => value.trim().toLowerCase();
-
-function register(name: string, config: KnownBroadcastDriverConfig): void {
-  registry.set(normalize(name), config);
-}
-
-function get(name: string): KnownBroadcastDriverConfig {
-  const key = normalize(name);
-  const found = registry.get(key);
-  if (found !== undefined) return found;
-  throw ErrorFactory.createConfigError(`Broadcast driver not configured: ${key}`);
-}
-
-function has(name: string): boolean {
-  return registry.has(normalize(name));
-}
-
-function list(): string[] {
-  return Array.from(registry.keys());
-}
-
-function reset(): void {
-  registry.clear();
-}
-
-export const BroadcastRegistry = Object.freeze({
-  register,
-  get,
-  has,
-  list,
-  reset,
-});

package/src/tools/broadcast/BroadcastRuntimeRegistration.ts

@@ -1,31 +0,0 @@
-import type { BroadcastConfigInput } from '@config/type';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-
-import { BroadcastRegistry } from '@broadcast/BroadcastRegistry';
-
-/**
- * Register broadcasters from runtime config.
- *
- * This follows the framework's config-driven availability pattern:
- * - Every `broadcastConfig.drivers[name]` is registered under `name`.
- * - The configured default name is also registered as `'default'`.
- * - Unknown names throw when selected via `BroadcastRegistry.get(name)`.
- */
-export function registerBroadcastersFromRuntimeConfig(
-  config: Pick<BroadcastConfigInput, 'default' | 'drivers'>
-): void {
-  for (const [name, driverConfig] of Object.entries(config.drivers)) {
-    BroadcastRegistry.register(name, driverConfig);
-  }
-
-  const defaultName = (config.default ?? '').toString().trim().toLowerCase();
-  if (defaultName.length === 0) {
-    throw ErrorFactory.createConfigError('Broadcast default driver is not configured');
-  }
-
-  if (!BroadcastRegistry.has(defaultName)) {
-    throw ErrorFactory.createConfigError(`Broadcast default driver not configured: ${defaultName}`);
-  }
-
-  BroadcastRegistry.register('default', BroadcastRegistry.get(defaultName));
-}

package/src/tools/broadcast/drivers/BaseDriver.ts

@@ -1,10 +0,0 @@
-import { ErrorFactory } from '@exceptions/ZintrustError';
-
-export const BaseDriver = Object.freeze({
-  async send(): Promise<unknown> {
-    await Promise.resolve();
-    throw ErrorFactory.createConfigError('Broadcast driver must implement send()');
-  },
-});
-
-export default BaseDriver;

package/src/tools/broadcast/drivers/InMemory.ts

@@ -1,20 +0,0 @@
-export const InMemoryDriver = Object.freeze({
-  _events: [] as Array<{ channel: string; event: string; data: unknown }>,
-
-  async send(_config: unknown, channel: string, event: string, data: unknown) {
-    // ensure function is async and returns a resolved promise
-    await Promise.resolve();
-    this._events.push({ channel, event, data });
-    return { ok: true };
-  },
-
-  getEvents() {
-    return this._events.slice();
-  },
-
-  reset() {
-    this._events.length = 0;
-  },
-});
-
-export default InMemoryDriver;

package/src/tools/broadcast/drivers/Pusher.ts

@@ -1,107 +0,0 @@
-import type { PusherBroadcastDriverConfig } from '@config/type';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { createHash, createHmac } from '@node-singletons/crypto';
-
-type PusherEventPayload = {
-  name: string;
-  channels: string[];
-  data: string;
-};
-
-const md5Hex = (data: string): string => createHash('md5').update(data).digest('hex');
-
-const buildQueryString = (params: Record<string, string>): string => {
-  const keys = Object.keys(params).sort((a, b) => a.localeCompare(b));
-  return keys
-    .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key] ?? '')}`)
-    .join('&');
-};
-
-const buildBaseUrl = (cluster: string): string => {
-  const normalized = cluster.trim();
-  if (normalized === '') return 'https://api.pusherapp.com';
-  return `https://api-${normalized}.pusher.com`;
-};
-
-const ensureConfig = (config: PusherBroadcastDriverConfig): void => {
-  if (config.appId.trim() === '') {
-    throw ErrorFactory.createConfigError(
-      'Pusher broadcast misconfigured: PUSHER_APP_ID is required'
-    );
-  }
-  if (config.key.trim() === '') {
-    throw ErrorFactory.createConfigError(
-      'Pusher broadcast misconfigured: PUSHER_APP_KEY is required'
-    );
-  }
-  if (config.secret.trim() === '') {
-    throw ErrorFactory.createConfigError(
-      'Pusher broadcast misconfigured: PUSHER_APP_SECRET is required'
-    );
-  }
-};
-
-const signRequest = (params: {
-  method: 'POST';
-  path: string;
-  secret: string;
-  queryString: string;
-}): string => {
-  const stringToSign = `${params.method}\n${params.path}\n${params.queryString}`;
-  return createHmac('sha256', params.secret).update(stringToSign).digest('hex');
-};
-
-export const PusherDriver = Object.freeze({
-  async send(config: PusherBroadcastDriverConfig, channel: string, event: string, data: unknown) {
-    ensureConfig(config);
-
-    const payload: PusherEventPayload = {
-      name: event,
-      channels: [channel],
-      data: JSON.stringify(data ?? null),
-    };
-
-    const body = JSON.stringify(payload);
-    const path = `/apps/${config.appId}/events`;
-
-    const authTimestamp = String(Math.floor(Date.now() / 1000));
-    const queryParams: Record<string, string> = {
-      auth_key: config.key,
-      auth_timestamp: authTimestamp,
-      auth_version: '1.0',
-      body_md5: md5Hex(body),
-    };
-
-    const queryString = buildQueryString(queryParams);
-    const authSignature = signRequest({ method: 'POST', path, secret: config.secret, queryString });
-
-    const baseUrl = buildBaseUrl(config.cluster);
-    const url = `${baseUrl}${path}?${queryString}&auth_signature=${authSignature}`;
-
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body,
-    });
-
-    if (!res.ok) {
-      let responseBody: string | undefined;
-      try {
-        responseBody = await res.text();
-      } catch {
-        responseBody = undefined;
-      }
-
-      throw ErrorFactory.createTryCatchError(`Pusher broadcast request failed (${res.status})`, {
-        status: res.status,
-        body: responseBody,
-      });
-    }
-
-    return { ok: true };
-  },
-});
-
-export default PusherDriver;

package/src/tools/broadcast/drivers/Redis.ts

@@ -1,49 +0,0 @@
-import { ensureDriver } from '@config/redis';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { createRedisKey } from '@tools/redis/RedisKeyManager';
-
-export type IRedisPublishClient = {
-  connect?: () => Promise<void>;
-  publish(channel: string, message: string): Promise<number>;
-};
-
-export type RedisBroadcastDriverConfig = {
-  driver: 'redis';
-  host: string;
-  port: number;
-  password: string;
-  channelPrefix: string;
-};
-
-const normalizePrefix = (value: string): string => {
-  const prefix = (value ?? '').trim();
-  return prefix || 'broadcast:';
-};
-
-export const RedisDriver = (() => {
-  return {
-    async send(config: RedisBroadcastDriverConfig, channel: string, event: string, data: unknown) {
-      const cli = await ensureDriver<IRedisPublishClient>('publish');
-
-      const prefixedChannel = createRedisKey(
-        `broadcast:${normalizePrefix(config.channelPrefix)}${channel}`
-      );
-
-      let message: string;
-      try {
-        message = JSON.stringify({ event, data });
-      } catch (err) {
-        throw ErrorFactory.createTryCatchError(
-          'Failed to serialize broadcast payload',
-          err as Error
-        );
-      }
-
-      const published = await cli.publish(prefixedChannel, message);
-
-      return { ok: true, published };
-    },
-  } as const;
-})();
-
-export default RedisDriver;

package/src/tools/broadcast/drivers/RedisHttps.ts

@@ -1,74 +0,0 @@
-import { Env } from '@config/env';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { HttpClient } from '@httpClient/Http';
-
-export type RedisHttpsBroadcastDriverConfig = {
-  driver: 'redishttps';
-  endpoint: string;
-  token: string;
-  channelPrefix: string;
-};
-
-const normalizePrefix = (value: string): string => {
-  const prefix = (value ?? '').trim();
-  return prefix || 'broadcast:';
-};
-
-const validateConfig = (config: RedisHttpsBroadcastDriverConfig): void => {
-  const endpoint = (config.endpoint ?? '').trim();
-  const token = (config.token ?? '').trim();
-
-  if (!endpoint) {
-    throw ErrorFactory.createConfigError(
-      'Redis HTTPS broadcast driver requires REDIS_HTTPS_ENDPOINT'
-    );
-  }
-
-  if (!token) {
-    throw ErrorFactory.createConfigError('Redis HTTPS broadcast driver requires REDIS_HTTPS_TOKEN');
-  }
-};
-
-export const RedisHttpsDriver = Object.freeze({
-  async send(
-    config: RedisHttpsBroadcastDriverConfig,
-    channel: string,
-    event: string,
-    data: unknown
-  ) {
-    validateConfig(config);
-
-    let message: string;
-    try {
-      message = JSON.stringify({ event, data });
-    } catch (err) {
-      throw ErrorFactory.createTryCatchError('Failed to serialize broadcast payload', err as Error);
-    }
-
-    const fullChannel = `${normalizePrefix(config.channelPrefix)}${channel}`;
-    const timeout = Env.getInt('REDIS_HTTPS_TIMEOUT', 5000);
-
-    const response = await HttpClient.post(config.endpoint, {
-      command: 'PUBLISH',
-      channel: fullChannel,
-      message,
-    })
-      .withAuth(config.token)
-      .withTimeout(timeout)
-      .send();
-
-    response.throwIfServerError();
-    response.throwIfClientError();
-
-    const published = (() => {
-      const trimmed = response.body.trim();
-      const asNum = Number(trimmed);
-      if (!Number.isFinite(asNum)) return undefined;
-      return asNum;
-    })();
-
-    return { ok: true, published };
-  },
-});
-
-export default RedisHttpsDriver;

package/src/tools/broadcast/index.ts

@@ -1,8 +0,0 @@
-export { Broadcast } from '@broadcast/Broadcast';
-export { BroadcastRegistry } from '@broadcast/BroadcastRegistry';
-export { registerBroadcastersFromRuntimeConfig } from '@broadcast/BroadcastRuntimeRegistration';
-export { BaseDriver } from '@broadcast/drivers/BaseDriver';
-export { InMemoryDriver } from '@broadcast/drivers/InMemory';
-export { PusherDriver } from '@broadcast/drivers/Pusher';
-export { RedisDriver } from '@broadcast/drivers/Redis';
-export { RedisHttpsDriver } from '@broadcast/drivers/RedisHttps';

package/src/tools/http/Http.ts

@@ -1,260 +0,0 @@
-/**
- * Http Client - Fluent HTTP request builder
- *
- * Usage:
- *   await HttpClient.get('https://api.example.com/users').withAuth(token).send();
- *   await HttpClient.post('https://api.example.com/users', data).withTimeout(5000).send();
- */
-
-import { OpenTelemetry } from '@/observability/OpenTelemetry';
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { createHttpResponse, type IHttpResponse } from '@httpClient/HttpResponse';
-
-export type { IHttpResponse } from '@httpClient/HttpResponse';
-
-/**
- * HTTP Request builder interface
- */
-export interface IHttpRequest {
-  withHeader(name: string, value: string): IHttpRequest;
-  withHeaders(headers: Record<string, string>): IHttpRequest;
-  withAuth(token: string, scheme?: 'Bearer' | 'Basic'): IHttpRequest;
-  withBasicAuth(username: string, password: string): IHttpRequest;
-  withTimeout(ms: number): IHttpRequest;
-  asJson(): IHttpRequest;
-  asForm(): IHttpRequest;
-  send(): Promise<IHttpResponse>;
-  sendRaw(): Promise<Response>;
-  sendStream(): Promise<{ response: Response; stream: ReadableStream<Uint8Array> | null }>;
-}
-
-/**
- * Internal request state
- */
-type BodyInitLocal = string | ArrayBuffer | Blob | FormData | URLSearchParams;
-
-interface RequestState {
-  method: string;
-  url: string;
-  headers: Record<string, string>;
-  body?: BodyInitLocal | null;
-  timeout?: number;
-  contentType?: 'json' | 'form';
-}
-
-/**
- * Perform the actual request for a given state. Separated to keep the builder small
- */
-async function performRequest(state: RequestState): Promise<IHttpResponse> {
-  const { response, bodyText, durationMs } = await performRequestRaw(state);
-
-  Logger.debug(`HTTP ${state.method} ${state.url}`, {
-    status: response.status,
-    duration: `${durationMs}ms`,
-    size: bodyText.length,
-  });
-
-  return createHttpResponse(response, bodyText);
-}
-
-async function performRequestRaw(
-  state: RequestState
-): Promise<{ response: Response; bodyText: string; durationMs: number }> {
-  const { response, durationMs } = await performFetch(state);
-  const bodyText = await response.text();
-  return { response, bodyText, durationMs };
-}
-
-async function performFetch(
-  state: RequestState
-): Promise<{ response: Response; durationMs: number }> {
-  const timeout = state.timeout ?? Env.getInt('HTTP_TIMEOUT', 30000);
-  const controller = new AbortController();
-
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  if (timeout > 0) {
-    timeoutId = globalThis.setTimeout(() => controller.abort(), timeout);
-  }
-
-  const buildInit = (): RequestInit => {
-    if (OpenTelemetry.isEnabled()) {
-      OpenTelemetry.injectTraceHeaders(state.headers);
-    }
-
-    const init: RequestInit = {
-      method: state.method,
-      headers: state.headers,
-      signal: controller.signal,
-    };
-
-    if (
-      state.body !== undefined &&
-      state.body !== null &&
-      ['POST', 'PUT', 'PATCH'].includes(state.method)
-    ) {
-      init.body = state.body;
-    }
-
-    return init;
-  };
-
-  try {
-    const init = buildInit();
-    const startTime = Date.now();
-    const response = await globalThis.fetch(state.url, init);
-    const duration = Date.now() - startTime;
-    return { response, durationMs: duration };
-  } catch (error) {
-    if (error instanceof Error && error.name === 'AbortError') {
-      throw ErrorFactory.createConnectionError(`HTTP request timeout after ${timeout}ms`, {
-        url: state.url,
-        method: state.method,
-        timeout,
-      });
-    }
-
-    throw ErrorFactory.createTryCatchError(`HTTP request failed: ${(error as Error).message}`, {
-      url: state.url,
-      method: state.method,
-      error: error instanceof Error ? error.message : String(error),
-    });
-  } finally {
-    if (timeoutId !== undefined) {
-      globalThis.clearTimeout(timeoutId);
-    }
-  }
-}
-
-/**
- * Create request builder with fluent API
- */
-function createRequestBuilder(
-  method: string,
-  url: string,
-  initialBody?: Record<string, unknown> | null
-): IHttpRequest {
-  const state: RequestState = {
-    method,
-    url,
-    headers: {
-      'User-Agent': 'ZinTrust/1.0',
-    },
-    body: initialBody ? JSON.stringify(initialBody) : undefined,
-  };
-
-  const self: IHttpRequest = {
-    withHeader(name: string, value: string): IHttpRequest {
-      state.headers[name] = value;
-      return self;
-    },
-
-    withHeaders(headers: Record<string, string>): IHttpRequest {
-      Object.assign(state.headers, headers);
-      return self;
-    },
-
-    withAuth(token: string, scheme: 'Bearer' | 'Basic' = 'Bearer'): IHttpRequest {
-      state.headers['Authorization'] = `${scheme} ${token}`;
-      return self;
-    },
-
-    withBasicAuth(username: string, password: string): IHttpRequest {
-      const credentials = Buffer.from(`${username}:${password}`).toString('base64');
-      state.headers['Authorization'] = `Basic ${credentials}`;
-      return self;
-    },
-
-    withTimeout(ms: number): IHttpRequest {
-      state.timeout = ms;
-      return self;
-    },
-
-    asJson(): IHttpRequest {
-      state.contentType = 'json';
-      state.headers['Content-Type'] = 'application/json';
-      return self;
-    },
-
-    asForm(): IHttpRequest {
-      state.contentType = 'form';
-      state.headers['Content-Type'] = 'application/x-www-form-urlencoded';
-      return self;
-    },
-
-    async send(): Promise<IHttpResponse> {
-      return performRequest(state);
-    },
-
-    async sendRaw(): Promise<Response> {
-      const { response } = await performFetch(state);
-      return response;
-    },
-
-    async sendStream(): Promise<{ response: Response; stream: ReadableStream<Uint8Array> | null }> {
-      const { response } = await performFetch(state);
-      return { response, stream: response.body };
-    },
-  };
-
-  return self;
-}
-
-/**
- * HTTP Client - Sealed namespace for making HTTP requests
- */
-export const HttpClient = Object.freeze({
-  /**
-   * Make GET request
-   */
-  get(url: string): IHttpRequest {
-    return createRequestBuilder('GET', url);
-  },
-
-  /**
-   * Make POST request
-   */
-  post(url: string, data?: Record<string, unknown>): IHttpRequest {
-    const builder = createRequestBuilder('POST', url, data);
-    if (data) {
-      builder.asJson();
-    }
-    return builder;
-  },
-
-  /**
-   * Make PUT request
-   */
-  put(url: string, data?: Record<string, unknown>): IHttpRequest {
-    const builder = createRequestBuilder('PUT', url, data);
-    if (data) {
-      builder.asJson();
-    }
-    return builder;
-  },
-
-  /**
-   * Make PATCH request
-   */
-  patch(url: string, data?: Record<string, unknown>): IHttpRequest {
-    const builder = createRequestBuilder('PATCH', url, data);
-    if (data) {
-      builder.asJson();
-    }
-    return builder;
-  },
-
-  /**
-   * Make DELETE request
-   */
-  delete(url: string, data?: Record<string, unknown>): IHttpRequest {
-    const builder = createRequestBuilder('DELETE', url, data);
-    if (data) {
-      builder.asJson();
-    }
-    return builder;
-  },
-});
-
-export default HttpClient;