@zintrust/core 0.1.26 → 0.1.28

package/bin/zintrust-microservices.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * ZinTrust Microservices CLI
+ * Commands for generating, bundling, and managing microservices
+ */
+
+import { Logger } from '@config/logger';
+import { MicroserviceGenerator } from '@microservices/MicroserviceGenerator';
+import { MicroserviceManager } from '@microservices/MicroserviceManager';
+import { ServiceBundler } from '@microservices/ServiceBundler';
+import { readFileSync } from '@node-singletons/fs';
+import { dirname, join } from '@node-singletons/path';
+import { fileURLToPath } from '@node-singletons/url';
+import { program } from 'commander';
+
+type CliOptions = Record<string, unknown>;
+
+const getStringOption = (options: CliOptions, key: string, fallback: string): string => {
+  const value = options[key];
+  return typeof value === 'string' && value.trim() !== '' ? value : fallback;
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Version
+const packageJsonUnknown: unknown = JSON.parse(
+  readFileSync(join(__dirname, '../package.json'), 'utf-8')
+);
+const packageVersion =
+  typeof packageJsonUnknown === 'object' &&
+  packageJsonUnknown !== null &&
+  'version' in packageJsonUnknown &&
+  typeof (packageJsonUnknown as { version: unknown }).version === 'string'
+    ? (packageJsonUnknown as { version: string }).version
+    : '0.0.0';
+
+program.version(packageVersion);
+
+/**
+ * Generate microservices
+ */
+program
+  .command('generate <domain> <services>')
+  .description('Generate microservices scaffold')
+  .option('--port <port>', 'Base port for services', '3001')
+  .option('--version <version>', 'Service version', '1.0.0')
+  .action(async (domain: string, services: string, options: CliOptions) => {
+    try {
+      const serviceList = services.split(',').map((s) => s.trim());
+      const portRaw = getStringOption(options, 'port', '3001');
+      const version = getStringOption(options, 'version', '1.0.0');
+
+      await MicroserviceGenerator.getInstance().generate({
+        domain,
+        services: serviceList,
+        basePort: Number.parseInt(portRaw, 10),
+        version,
+      });
+
+      Logger.info('Microservices generated successfully');
+    } catch (error) {
+      Logger.error('Error generating microservices:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Bundle services
+ */
+program
+  .command('bundle <domain> <services>')
+  .description('Bundle microservices for deployment')
+  .option('--output <dir>', 'Output directory', 'dist/services')
+  .option('--target-size <mb>', 'Target bundle size in MB', '1')
+  .action(async (domain: string, services: string, options: CliOptions) => {
+    try {
+      const serviceList = services.split(',').map((s) => s.trim());
+      const outputDir = getStringOption(options, 'output', 'dist/services');
+
+      const results = await ServiceBundler.getInstance().bundleAll(domain, serviceList, outputDir);
+
+      const allOptimized = results.every((r: { optimized: boolean }) => r.optimized === true);
+      if (allOptimized === false) {
+        Logger.warn('Some services exceed target size. Consider optimizing bundle.');
+      }
+    } catch (error) {
+      Logger.error('Error bundling microservices:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Create Docker images
+ */
+program
+  .command('docker <domain> <services>')
+  .description('Create Docker images for services')
+  .option('--registry <url>', 'Docker registry URL', 'localhost:5000')
+  .action(async (domain: string, services: string, options: CliOptions) => {
+    try {
+      const serviceList = services.split(',').map((s) => s.trim());
+      const registry = getStringOption(options, 'registry', 'localhost:5000');
+
+      await Promise.all(
+        serviceList.map((service) =>
+          ServiceBundler.getInstance().createServiceImage(service, domain, registry)
+        )
+      );
+
+      Logger.info(
+        `Docker images ready. Build with:\n  docker-compose -f services/${domain}/docker-compose.yml build`
+      );
+    } catch (error) {
+      Logger.error('Error creating Docker images:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Discover services
+ */
+program
+  .command('discover')
+  .description('Discover available microservices')
+  .action(async () => {
+    try {
+      const configs = await MicroserviceManager.discoverServices();
+
+      if (configs.length === 0) {
+        Logger.info('No microservices found in services/ folder');
+        return;
+      }
+
+      Logger.info(`Found ${configs.length} microservice(s):`);
+
+      for (const config of configs) {
+        const version =
+          config.version !== undefined && config.version !== null && config.version !== ''
+            ? config.version
+            : '1.0.0';
+
+        Logger.info(`  • ${config.name} (${config.domain}) - v${version}`);
+
+        if (
+          config.dependencies !== undefined &&
+          config.dependencies !== null &&
+          config.dependencies.length > 0
+        ) {
+          Logger.info(`    Dependencies: ${config.dependencies.join(', ')}`);
+        }
+      }
+    } catch (error) {
+      Logger.error('Error discovering services:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Status of services
+ */
+program
+  .command('status')
+  .description('Check status of running microservices')
+  .action(async () => {
+    try {
+      const manager = MicroserviceManager.getInstance();
+      const summary = manager.getStatusSummary();
+
+      Logger.info(`Microservices Status:\n${JSON.stringify(summary, null, 2)}`);
+    } catch (error) {
+      Logger.error('Error getting microservices status:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Health check
+ */
+program
+  .command('health')
+  .description('Health check all services')
+  .action(async () => {
+    try {
+      const manager = MicroserviceManager.getInstance();
+      const results = await manager.healthCheckAll();
+
+      Logger.info('Health Check Results');
+      for (const [service, healthy] of Object.entries(results)) {
+        Logger.info(`  ${service}: ${healthy ? 'Healthy' : 'Unhealthy'}`);
+      }
+    } catch (error) {
+      Logger.error('Error performing health check:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/bin/zintrust.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env -S node --import tsx
+
+/**
+ * ZinTrust CLI - Main Entry Point
+ *
+ * This bin script is a thin wrapper around the hashbang-free implementation in
+ * bin/zintrust-main.ts. Keeping the implementation hashbang-free allows other
+ * shortcuts (zin/z/zt) to import it without parse issues.
+ */
+
+import { run } from './zintrust-main.js';
+
+await run();
+export {};

package/bin/zt.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env -S node --import tsx
+
+/**
+ * ZinTrust CLI Shortcut - 'z'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+
+import { run } from './zintrust-main.js';
+
+await run();

package/dist/src/index.d.ts

@@ -0,0 +1,258 @@
+/**
+ * ZinTrust Framework - Production-Grade TypeScript Backend
+ * Built for performance, type safety, and exceptional developer experience
+ */
+/**
+ * Framework version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export declare const ZINTRUST_VERSION = "0.1.23";
+export declare const ZINTRUST_BUILD_DATE = "__BUILD_DATE__";
+declare const ZintrustApplication: Readonly<{
+    create(basePath?: string): import("./boot/Application").IApplication;
+}>;
+declare const ZintrustAwsSigV4: Readonly<{
+    sha256Hex(data: string | Uint8Array): string;
+    hmacSha256(key: Uint8Array | string, data: string): Uint8Array;
+    toAmzDate(date: Date): {
+        amzDate: string;
+        dateStamp: string;
+    };
+    deriveSigningKey(params: {
+        secretAccessKey: string;
+        dateStamp: string;
+        region: string;
+        service: string;
+    }): Uint8Array;
+    canonicalizeHeaders(headers: Record<string, string>): {
+        canonicalHeaders: string;
+        signedHeaders: string;
+    };
+    buildAuthorization(params: {
+        method: string;
+        canonicalUri: string;
+        canonicalQueryString: string;
+        headers: Record<string, string>;
+        payloadHash: string;
+        region: string;
+        service: string;
+        amzDate: string;
+        dateStamp: string;
+        credentials: import("./common/AwsSigV4").AwsSigV4Credentials;
+    }): {
+        authorization: string;
+        signedHeaders: string;
+    };
+}>;
+declare const ZintrustSignedRequest: Readonly<{
+    sha256Hex: (data: string | Uint8Array) => Promise<string>;
+    canonicalString: (params: {
+        method: string;
+        url: string | URL;
+        timestampMs: number;
+        nonce: string;
+        bodySha256Hex: string;
+    }) => string;
+    createHeaders(params: import("./security/SignedRequest").SignedRequestCreateHeadersParams): Promise<import("./security/SignedRequest").SignedRequestHeaders>;
+    verify(params: import("./security/SignedRequest").SignedRequestVerifyParams): Promise<import("./security/SignedRequest").SignedRequestVerifyResult>;
+}>;
+export { Server } from './boot/Server';
+export { ServiceContainer } from './container/ServiceContainer';
+export { createPaginator, getNextPageUrl, getPrevPageUrl, Paginator } from './database/Paginator';
+export type { CreatePaginatorInput, PaginationLinks, PaginationQuery, Paginator as PaginatorType, } from './database/Paginator';
+export { Controller } from './http/Controller';
+export { FileUpload } from './http/FileUpload';
+export type { FileUploadOptions, IFileUploadHandler, UploadedFile } from './http/FileUpload';
+export { Kernel } from './http/Kernel';
+export { bodyParsingMiddleware } from './http/middleware/BodyParsingMiddleware';
+export { fileUploadMiddleware } from './http/middleware/FileUploadMiddleware';
+export { BodyParsers } from './http/parsers/BodyParsers';
+export { MultipartParser } from './http/parsers/MultipartParser';
+export { MultipartParserRegistry } from './http/parsers/MultipartParserRegistry';
+export type { MultipartFieldValue, MultipartParseInput, MultipartParserProvider, ParsedMultipartData, } from './http/parsers/MultipartParserRegistry';
+export { Request } from './http/Request';
+export type { IRequest, ValidatedRequest } from './http/Request';
+export { RequestContext } from './http/RequestContext';
+export { Response } from './http/Response';
+export type { IResponse } from './http/Response';
+export { getValidatedBody, getValidatedHeaders, getValidatedParams, getValidatedQuery, hasValidatedBody, requireValidatedBody, ValidationHelper, } from './http/ValidationHelper';
+export { CsrfMiddleware } from './middleware/CsrfMiddleware';
+export { ErrorHandlerMiddleware } from './middleware/ErrorHandlerMiddleware';
+export { LoggingMiddleware } from './middleware/LoggingMiddleware';
+export { MiddlewareStack } from './middleware/MiddlewareStack';
+export type { Middleware } from './middleware/MiddlewareStack';
+export { RateLimiter } from './middleware/RateLimiter';
+export { SecurityMiddleware } from './middleware/SecurityMiddleware';
+export { SessionMiddleware } from './middleware/SessionMiddleware';
+export { ValidationMiddleware } from './middleware/ValidationMiddleware';
+export { MySQLAdapter } from './orm/adapters/MySQLAdapter';
+export { PostgreSQLAdapter } from './orm/adapters/PostgreSQLAdapter';
+export { SQLiteAdapter } from './orm/adapters/SQLiteAdapter';
+export { SQLServerAdapter } from './orm/adapters/SQLServerAdapter';
+export { Database, resetDatabase, useDatabase, useEnsureDbConnected } from './orm/Database';
+export type { IDatabase } from './orm/Database';
+export { Model } from './orm/Model';
+export type { IModel, ModelConfig, ModelStatic } from './orm/Model';
+export { QueryBuilder } from './orm/QueryBuilder';
+export type { InsertResult, IQueryBuilder, PaginationOptions } from './orm/QueryBuilder';
+export type { IRelationship } from './orm/Relationships';
+export { ZintrustApplication as Application };
+export { DateTime } from './time/DateTime';
+export type { IDateTime } from './time/DateTime';
+export { Schema as MigrationSchema, type Blueprint } from './migrations/schema';
+export { OpenApiGenerator } from './openapi/OpenApiGenerator';
+export type { OpenApiGeneratorOptions } from './openapi/OpenApiGenerator';
+export { Router } from './routes/Router';
+export type { IRouter } from './routes/Router';
+export { normalizeRouteMeta, RouteRegistry } from './routes/RouteRegistry';
+export type { RouteMeta, RouteMetaInput, RouteRegistration } from './routes/RouteRegistry';
+export { DatabaseAdapterRegistry } from './orm/DatabaseAdapterRegistry';
+export { generateSecureJobId, generateUuid, getString, Utilities, type UtilitiesType, } from './common/utility';
+export { delay, ensureDirSafe } from './common/index';
+export { ZintrustAwsSigV4 as AwsSigV4 };
+export { collect, Collection } from './collections/index';
+export type { ICollection, PrimitiveKey } from './collections/index';
+export { HttpClient } from './tools/http/Http';
+export type { IHttpRequest, IHttpResponse } from './tools/http/Http';
+export type { DatabaseConfig, ID1Database, IDatabaseAdapter, QueryResult, } from './orm/DatabaseAdapter';
+export { MemoryProfiler } from './profiling/MemoryProfiler';
+export { N1Detector } from './profiling/N1Detector';
+export { QueryLogger } from './profiling/QueryLogger';
+export { RequestProfiler } from './profiling/RequestProfiler';
+export type { MemoryDelta, MemorySnapshot, N1Pattern, ProfileReport, QueryLogEntry, } from './profiling/types';
+export { GenerationCache, LazyLoader, Memoize, ParallelGenerator, PerformanceOptimizer, runAll, runBatch, } from './performance/Optimizer';
+export type { IGenerationCache, ILazyLoader, IPerformanceOptimizer } from './performance/Optimizer';
+export { OpenTelemetry } from './observability/OpenTelemetry';
+export { PrometheusMetrics } from './observability/PrometheusMetrics';
+export type { ObserveDbQueryInput, ObserveHttpRequestInput, } from './observability/PrometheusMetrics';
+export { ValidationError } from './validation/ValidationError';
+export type { FieldError } from './validation/ValidationError';
+export { Schema, Validator } from './validation/Validator';
+export type { ISchema, SchemaType } from './validation/Validator';
+export { CsrfTokenManager } from './security/CsrfTokenManager';
+export type { CsrfTokenData, CsrfTokenManagerType, ICsrfTokenManager, } from './security/CsrfTokenManager';
+export { EncryptedEnvelope } from './security/EncryptedEnvelope';
+export { Encryptor } from './security/Encryptor';
+export { Hash } from './security/Hash';
+export { JwtManager } from './security/JwtManager';
+export type { IJwtManager, JwtAlgorithm, JwtManagerType, JwtOptions, JwtPayload, } from './security/JwtManager';
+export { PasswordResetTokenBroker } from './security/PasswordResetTokenBroker';
+export type { IPasswordResetTokenBroker, IPasswordResetTokenStore, PasswordResetTokenBrokerOptions, PasswordResetTokenBrokerType, PasswordResetTokenRecord, } from './security/PasswordResetTokenBroker';
+export { createSanitizer, Sanitizer, type SanitizerType } from './security/Sanitizer';
+export { TokenRevocation } from './security/TokenRevocation';
+export { Xss } from './security/Xss';
+export { XssProtection } from './security/XssProtection';
+export { ZintrustSignedRequest as SignedRequest };
+export { ErrorFactory } from './exceptions/ZintrustError';
+export { EventDispatcher } from './events/EventDispatcher';
+export type { EventListener, EventMap, IEventDispatcher } from './events/EventDispatcher';
+export { SessionManager } from './session/SessionManager';
+export type { ISession, ISessionManager, SessionData, SessionManagerOptions, } from './session/SessionManager';
+export { Env } from './config/env';
+export { Logger } from './config/logger';
+export { appConfig } from './config/app';
+export type { AppConfig } from './config/app';
+export { cacheConfig } from './config/cache';
+export type { CacheConfig, CacheConfigOverrides } from './config/cache';
+export { Cache, cache } from './cache/Cache';
+export type { CacheDriver } from './cache/CacheDriver';
+export { registerCachesFromRuntimeConfig } from './cache/CacheRuntimeRegistration';
+export { CacheDriverRegistry } from './cache/CacheDriverRegistry';
+export { databaseConfig } from './config/database';
+export type { DatabaseConfigOverrides, DatabaseConfig as DatabaseRuntimeConfig, } from './config/database';
+export { registerDatabasesFromRuntimeConfig } from './orm/DatabaseRuntimeRegistration';
+export { microservicesConfig } from './config/microservices';
+export type { MicroservicesConfig } from './config/microservices';
+export { MicroserviceBootstrap } from './microservices/MicroserviceBootstrap';
+export type { IMicroserviceBootstrap, ServiceConfig } from './microservices/MicroserviceBootstrap';
+export { MicroserviceManager } from './microservices/MicroserviceManager';
+export type { IMicroserviceManager, MicroserviceConfig } from './microservices/MicroserviceManager';
+export { RequestTracingMiddleware } from './microservices/RequestTracingMiddleware';
+export { ServiceAuthMiddleware } from './microservices/ServiceAuthMiddleware';
+export { HealthCheckHandler, ServiceHealthMonitor } from './microservices/ServiceHealthMonitor';
+export type { AggregatedHealthStatus, HealthCheckResult, IServiceHealthMonitor, } from './microservices/ServiceHealthMonitor';
+export { middlewareConfig, MiddlewareKeys } from './config/middleware';
+export type { MiddlewareKey } from './config/middleware';
+export type { MiddlewareConfigType } from './config/type';
+export { createBaseDrivers, queueConfig } from './config/queue';
+export type { QueueConfig, QueueConfigOverrides } from './config/queue';
+export { default as broadcastConfig } from './config/broadcast';
+export type { BroadcastConfigOverrides } from './config/broadcast';
+export { default as notificationConfig } from './config/notification';
+export type { NotificationConfig, NotificationConfigOverrides } from './config/notification';
+export { securityConfig } from './config/security';
+export { mailConfig } from './config/mail';
+export type { MailConfig, MailConfigOverrides } from './config/mail';
+export { storageConfig } from './config/storage';
+export type { StorageConfig, StorageConfigOverrides } from './config/storage';
+export { startupConfig } from './config/startup';
+export type { StartupConfig } from './config/startup';
+export { Constants, DEFAULTS, ENV_KEYS, HTTP_HEADERS, MIME_TYPES } from './config/constants';
+export { FeatureFlags } from './config/features';
+export { Cloudflare } from './config/cloudflare';
+export { getDatabaseCredentials, getJwtSecrets, SECRETS, SecretsManager, } from './config/SecretsManager';
+export type { DatabaseCredentials, JwtSecrets } from './config/SecretsManager';
+export type { MailDriverConfig, MailDriverName, WorkersEnv } from './config/type';
+export { StartupConfigValidator } from './config/StartupConfigValidator';
+export { Mail } from './tools/mail';
+export type { SendMailInput, SendMailResult } from './tools/mail';
+export { MailTemplateRenderer, MailTemplates } from './tools/mail/templates';
+export type { MailTemplate, MailTemplateRegistry } from './tools/mail/templates';
+export { MailDriverRegistry } from './tools/mail/MailDriverRegistry';
+export { registerQueuesFromRuntimeConfig } from './tools/queue/QueueRuntimeRegistration';
+export { SmtpDriver } from './tools/mail/drivers/Smtp';
+export type { SmtpConfig as SmtpDriverConfig } from './tools/mail/drivers/Smtp';
+export { SendGridDriver } from './tools/mail/drivers/SendGrid';
+export type { SendGridConfig, MailAddress as SendGridMailAddress, MailAttachment as SendGridMailAttachment, MailMessage as SendGridMailMessage, SendResult as SendGridSendResult, } from './tools/mail/drivers/SendGrid';
+export { MailgunDriver } from './tools/mail/drivers/Mailgun';
+export type { MailgunConfig, MailMessage as MailgunMessage, SendResult as MailgunResult, } from './tools/mail/drivers/Mailgun';
+export { sendSlackWebhook } from './tools/notification/drivers/Slack';
+export { TermiiDriver } from './tools/notification/drivers/Termii';
+export { sendSms } from './tools/notification/drivers/Twilio';
+export { Notification } from './tools/notification/Notification';
+export { NotificationRegistry } from './tools/notification/Registry';
+export { MarkdownRenderer } from './tools/templates';
+export { RuntimeHealthProbes } from './health/RuntimeHealthProbes';
+export { Broadcast } from './tools/broadcast/Broadcast';
+export { BroadcastRegistry } from './tools/broadcast/BroadcastRegistry';
+export { registerBroadcastersFromRuntimeConfig } from './tools/broadcast/BroadcastRuntimeRegistration';
+export { BroadcastWorker } from '../packages/workers/src/index.js';
+export { NotificationWorker } from '../packages/workers/src/index.js';
+export { Storage } from './tools/storage/index';
+export { LocalSignedUrl } from './tools/storage/LocalSignedUrl';
+export { StorageDriverRegistry } from './tools/storage/StorageDriverRegistry';
+export { S3Driver } from './tools/storage/drivers/S3';
+export type { S3Config } from './tools/storage/drivers/S3';
+export { R2Driver } from './tools/storage/drivers/R2';
+export type { R2Config } from './tools/storage/drivers/R2';
+export { GcsDriver } from './tools/storage/drivers/Gcs';
+export type { GcsConfig } from './tools/storage/drivers/Gcs';
+export { RedisQueue } from './tools/queue/drivers/Redis';
+export { createLockProvider, getLockProvider, registerLockProvider } from './tools/queue/LockProvider';
+export { Queue, resolveLockPrefix } from './tools/queue/Queue';
+export type { QueueMessage } from './tools/queue/Queue';
+export { SeederLoader } from './seeders/SeederLoader';
+export type { LoadedSeeder, SeederHandler } from './seeders/types';
+export { default as logCleanup } from './schedules/log-cleanup';
+export * as NodeSingletons from './node-singletons/index';
+export { Auth } from './auth/Auth';
+export { MicroserviceGenerator } from './microservices/MicroserviceGenerator';
+export type { GenerateServiceOptions, IMicroserviceGenerator, } from './microservices/MicroserviceGenerator';
+export { BaseCommand } from './cli/BaseCommand';
+export type { CommandOptions } from './cli/BaseCommand';
+export { CLI } from './cli/CLI';
+export { ErrorHandler, EXIT_CODES } from './cli/ErrorHandler';
+export { getKernel } from './runtime/getKernel';
+export { useFileLoader } from './runtime/useFileLoader';
+export { PluginManager } from './runtime/PluginManager';
+export { PluginRegistry } from './runtime/PluginRegistry';
+export { nowIso } from './common/utility';
+export type { SanitizerError } from './exceptions/ZintrustError';
+export { randomBytes } from './node-singletons/crypto';
+export type { MiddlewaresType } from './config/middleware';
+export * from './config/redis';
+export type * from './config/type';
+export { ZintrustLang } from './lang/lang';
+export { createRedisConnection, workersConfig } from './config/workers';
+export { createBullMQKey, createCacheKey, createKeyByType, createQueueKey, createRedisKey, createSessionKey, createWorkerKey, extractOriginalKey, getBullMQSafeQueueName, getPrefix, isAppKey, type RedisKeyType, } from './tools/redis/RedisKeyManager';
+//# sourceMappingURL=index.d.ts.map