@zintrust/core 0.1.26 → 0.1.28

package/src/services/ecommerce/docker-compose.yml

@@ -0,0 +1,155 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/compose-spec/compose-spec/master/schema/compose-spec.json
+version: '3.9'
+
+services:
+  # PostgreSQL database (shared for all services or per-service based on config)
+  postgres:
+    image: postgres:16-alpine
+    container_name: zintrust-postgres
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-zintrust}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    ports:
+      - '5432:5432'
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./init-db.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U postgres']
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - ecommerce-network
+
+  # Users Microservice
+  users:
+    build:
+      context: ../..
+      dockerfile: services/ecommerce/users/Dockerfile
+    container_name: zintrust-users-service
+    environment:
+      SERVICE_NAME: users
+      SERVICE_PORT: 3001
+      MICROSERVICES: 'true'
+      POSTGRES_HOST: postgres
+      POSTGRES_DB: ${POSTGRES_DB:-zintrust}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      DATABASE_ISOLATION: shared
+      AUTH_STRATEGY: api-key
+      MICROSERVICES_TRACING: 'true'
+      MICROSERVICES_TRACING_RATE: '1.0'
+    ports:
+      - '3001:3001'
+    depends_on:
+      postgres:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD', 'curl', '-f', 'http://localhost:3001/health']
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    networks:
+      - ecommerce-network
+    restart: unless-stopped
+
+  # Orders Microservice
+  orders:
+    build:
+      context: ../..
+      dockerfile: services/ecommerce/orders/Dockerfile
+    container_name: zintrust-orders-service
+    environment:
+      SERVICE_NAME: orders
+      SERVICE_PORT: 3002
+      MICROSERVICES: 'true'
+      POSTGRES_HOST: postgres
+      POSTGRES_DB: ${POSTGRES_DB:-zintrust}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      DATABASE_ISOLATION: shared
+      AUTH_STRATEGY: jwt
+      MICROSERVICES_TRACING: 'true'
+      MICROSERVICES_TRACING_RATE: '0.5'
+      SERVICE_DEPENDENCIES: users,payments
+    ports:
+      - '3002:3002'
+    depends_on:
+      postgres:
+        condition: service_healthy
+      users:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD', 'curl', '-f', 'http://localhost:3002/health']
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    networks:
+      - ecommerce-network
+    restart: unless-stopped
+
+  # Payments Microservice
+  payments:
+    build:
+      context: ../..
+      dockerfile: services/ecommerce/payments/Dockerfile
+    container_name: zintrust-payments-service
+    environment:
+      SERVICE_NAME: payments
+      SERVICE_PORT: 7777
+      MICROSERVICES: 'true'
+      POSTGRES_HOST: postgres
+      POSTGRES_DB: ${POSTGRES_DB:-zintrust_payments}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      DATABASE_ISOLATION: isolated
+      AUTH_STRATEGY: none
+      MICROSERVICES_TRACING: 'false'
+      SERVICE_DEPENDENCIES: orders
+    ports:
+      - '7777:7777'
+    depends_on:
+      postgres:
+        condition: service_healthy
+      orders:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD', 'curl', '-f', 'http://localhost:7777/health']
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    networks:
+      - ecommerce-network
+    restart: unless-stopped
+
+  # API Gateway (optional - routes requests to appropriate services)
+  api-gateway:
+    build:
+      context: ../..
+      dockerfile: services/ecommerce/gateway/Dockerfile
+    container_name: zintrust-api-gateway
+    environment:
+      GATEWAY_PORT: 8000
+      MICROSERVICES: 'true'
+      SERVICES: users,orders,payments
+    ports:
+      - '8000:8000'
+    depends_on:
+      users:
+        condition: service_healthy
+      orders:
+        condition: service_healthy
+      payments:
+        condition: service_healthy
+    networks:
+      - ecommerce-network
+    restart: unless-stopped
+
+volumes:
+  postgres_data:
+
+networks:
+  ecommerce-network:
+    driver: bridge

package/src/services/ecommerce/init-db.sql

@@ -0,0 +1,71 @@
+-- Initialize ZinTrust microservices databases
+-- This script runs once when PostgreSQL container starts
+
+-- Create schemas for shared database isolation
+CREATE SCHEMA IF NOT EXISTS ecommerce_users;
+CREATE SCHEMA IF NOT EXISTS ecommerce_orders;
+CREATE SCHEMA IF NOT EXISTS ecommerce_payments;
+
+-- Users service tables
+CREATE TABLE IF NOT EXISTS ecommerce_users.users (
+  id SERIAL PRIMARY KEY,
+  email VARCHAR(255) UNIQUE NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  password_hash VARCHAR(255),
+  is_active BOOLEAN DEFAULT true,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_users_email ON ecommerce_users.users(email);
+CREATE INDEX idx_users_active ON ecommerce_users.users(is_active);
+
+-- Orders service tables
+CREATE TABLE IF NOT EXISTS ecommerce_orders.orders (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER NOT NULL,
+  total_amount DECIMAL(10, 2) NOT NULL,
+  status VARCHAR(50) DEFAULT 'pending',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_orders_user_id ON ecommerce_orders.orders(user_id);
+CREATE INDEX idx_orders_status ON ecommerce_orders.orders(status);
+
+CREATE TABLE IF NOT EXISTS ecommerce_orders.order_items (
+  id SERIAL PRIMARY KEY,
+  order_id INTEGER NOT NULL,
+  product_name VARCHAR(255) NOT NULL,
+  quantity INTEGER NOT NULL,
+  price DECIMAL(10, 2) NOT NULL,
+  FOREIGN KEY (order_id) REFERENCES ecommerce_orders.orders(id) ON DELETE CASCADE
+);
+
+-- Payments service tables (can be in separate database if needed)
+CREATE TABLE IF NOT EXISTS ecommerce_payments.payments (
+  id SERIAL PRIMARY KEY,
+  order_id INTEGER NOT NULL,
+  amount DECIMAL(10, 2) NOT NULL,
+  status VARCHAR(50) DEFAULT 'pending',
+  payment_method VARCHAR(50),
+  transaction_id VARCHAR(255),
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_payments_order_id ON ecommerce_payments.payments(order_id);
+CREATE INDEX idx_payments_status ON ecommerce_payments.payments(status);
+
+-- Grant permissions to postgres user
+GRANT ALL PRIVILEGES ON SCHEMA ecommerce_users TO postgres;
+GRANT ALL PRIVILEGES ON SCHEMA ecommerce_orders TO postgres;
+GRANT ALL PRIVILEGES ON SCHEMA ecommerce_payments TO postgres;
+
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ecommerce_users TO postgres;
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ecommerce_orders TO postgres;
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ecommerce_payments TO postgres;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA ecommerce_users GRANT ALL ON TABLES TO postgres;
+ALTER DEFAULT PRIVILEGES IN SCHEMA ecommerce_orders GRANT ALL ON TABLES TO postgres;
+ALTER DEFAULT PRIVILEGES IN SCHEMA ecommerce_payments GRANT ALL ON TABLES TO postgres;

package/src/services/ecommerce/orders/service.config.json

@@ -0,0 +1,20 @@
+{
+  "name": "orders",
+  "version": "1.0.0",
+  "port": 3002,
+  "domain": "ecommerce",
+  "description": "Order management microservice with user and payment integration",
+  "dependencies": ["users", "payments"],
+  "healthCheck": "/health",
+  "database": {
+    "isolation": "shared",
+    "migrations": true
+  },
+  "auth": {
+    "strategy": "jwt"
+  },
+  "tracing": {
+    "enabled": true,
+    "samplingRate": 0.5
+  }
+}

package/src/services/ecommerce/payments/service.config.json

@@ -0,0 +1,19 @@
+{
+  "name": "payments",
+  "version": "1.0.0",
+  "port": 7777,
+  "domain": "ecommerce",
+  "description": "Payment processing microservice",
+  "dependencies": ["orders"],
+  "healthCheck": "/health",
+  "database": {
+    "isolation": "isolated",
+    "migrations": true
+  },
+  "auth": {
+    "strategy": "none"
+  },
+  "tracing": {
+    "enabled": false
+  }
+}

package/src/services/ecommerce/users/Dockerfile

@@ -0,0 +1,57 @@
+# Multi-stage build for microservice
+# Target: < 1 MB final image
+
+# Stage 1: Build
+FROM node:20-alpine@sha256:fcbb8f7d018707c656a4da2eea8a15f2893d2258093fea9ff2ea5ea1cba82112 AS builder
+
+WORKDIR /build
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production --ignore-scripts && \
+    npm cache clean --force
+
+# Copy source code
+COPY services/ecommerce/users/src ./src
+COPY tsconfig.json ./
+
+# Build TypeScript
+RUN npm run build 2>/dev/null || true
+
+# Stage 2: Runtime
+FROM node:20-alpine@sha256:fcbb8f7d018707c656a4da2eea8a15f2893d2258093fea9ff2ea5ea1cba82112
+
+WORKDIR /app
+
+# Install curl for health checks
+RUN apk add --no-cache curl
+
+# Copy built artifacts from builder
+COPY --from=builder /build/node_modules ./node_modules
+COPY --from=builder /build/dist ./dist
+
+# Copy package.json only
+COPY package.json ./
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+USER nodejs
+
+# Set environment
+ENV NODE_ENV=production
+ENV SERVICE_NAME=users
+ENV SERVICE_PORT=3001
+
+# Expose port
+EXPOSE 3001
+
+# Health check
+HEALTHCHECK --interval=10s --timeout=5s --retries=3 \
+  CMD curl -f http://localhost:3001/health || exit 1
+
+# Start service
+CMD ["node", "dist/src/Kernel.js"]

package/src/services/ecommerce/users/service.config.json

@@ -0,0 +1,20 @@
+{
+  "name": "users",
+  "version": "1.0.0",
+  "port": 3001,
+  "domain": "ecommerce",
+  "description": "User management microservice",
+  "dependencies": [],
+  "healthCheck": "/health",
+  "database": {
+    "isolation": "shared",
+    "migrations": true
+  },
+  "auth": {
+    "strategy": "api-key"
+  },
+  "tracing": {
+    "enabled": true,
+    "samplingRate": 1.0
+  }
+}

package/src/session/SessionManager.ts

@@ -0,0 +1,241 @@
+import { generateSecureJobId } from '@/common/utility';
+
+export type SessionData = Record<string, unknown>;
+
+export interface ISession {
+  id: string;
+  get<T = unknown>(key: string): T | undefined;
+  set(key: string, value: unknown): void;
+  has(key: string): boolean;
+  forget(key: string): void;
+  all(): SessionData;
+  clear(): void;
+}
+
+export interface ISessionManager {
+  getIdFromCookieHeader(cookieHeader: string | undefined): string | undefined;
+  getIdFromRequest(req: {
+    getHeader: (name: string) => unknown;
+    sessionId?: unknown;
+    context?: Record<string, unknown>;
+  }): string | undefined;
+  ensureSessionId(
+    req: {
+      getHeader: (name: string) => unknown;
+      sessionId?: unknown;
+      context: Record<string, unknown>;
+    },
+    res: {
+      getHeader: (name: string) => unknown;
+      setHeader: (name: string, value: string | string[]) => unknown;
+    }
+  ): Promise<string>;
+  get(sessionId: string): ISession;
+  destroy(sessionId: string): void;
+  cleanup(): number;
+}
+
+export interface SessionManagerOptions {
+  cookieName?: string;
+  headerName?: string;
+  ttlMs?: number;
+}
+
+type StoredSession = {
+  data: SessionData;
+  expiresAt: number;
+};
+
+const DEFAULT_OPTIONS: Required<SessionManagerOptions> = {
+  cookieName: 'ZIN_SESSION_ID',
+  headerName: 'x-session-id',
+  ttlMs: 7 * 24 * 60 * 60 * 1000,
+};
+
+function parseCookies(cookieHeader: string): Record<string, string> {
+  const list: Record<string, string> = {};
+  if (cookieHeader.length === 0) return list;
+
+  cookieHeader.split(';').forEach((cookie) => {
+    const parts = cookie.split('=');
+    const name = parts.shift()?.trim();
+    const value = parts.join('=');
+    if (name !== null && name !== undefined) list[name] = decodeURIComponent(value);
+  });
+
+  return list;
+}
+
+function appendSetCookie(
+  res: {
+    getHeader: (name: string) => unknown;
+    setHeader: (name: string, value: string | string[]) => unknown;
+  },
+  cookie: string
+): void {
+  const existing = res.getHeader('Set-Cookie');
+
+  if (existing === undefined) {
+    res.setHeader('Set-Cookie', cookie);
+    return;
+  }
+
+  if (Array.isArray(existing)) {
+    const existingCookies = existing.map(String);
+    res.setHeader('Set-Cookie', [...existingCookies, cookie]);
+    return;
+  }
+
+  if (typeof existing === 'string') {
+    res.setHeader('Set-Cookie', [existing, cookie]);
+    return;
+  }
+
+  res.setHeader('Set-Cookie', cookie);
+}
+
+function buildSessionCookie(cookieName: string, sessionId: string): string {
+  // Keep this minimal; callers can override behavior later.
+  // HttpOnly prevents JS access; SameSite=Lax is a reasonable default for app sessions.
+  return `${cookieName}=${encodeURIComponent(sessionId)}; Path=/; HttpOnly; SameSite=Lax`;
+}
+
+function createSessionApi(
+  sessions: Map<string, StoredSession>,
+  sessionId: string,
+  ttlMs: number
+): ISession {
+  const withoutKey = (data: SessionData, key: string): SessionData => {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) return data;
+    const record = data as Record<string, unknown>;
+    const { [key]: _removed, ...rest } = record;
+    return rest;
+  };
+
+  const ensureStored = (): StoredSession => {
+    const existing = sessions.get(sessionId);
+    const now = Date.now();
+
+    if (existing !== undefined && existing.expiresAt > now) {
+      return existing;
+    }
+
+    const created: StoredSession = { data: {}, expiresAt: now + ttlMs };
+    sessions.set(sessionId, created);
+    return created;
+  };
+
+  return {
+    id: sessionId,
+
+    get<T = unknown>(key: string): T | undefined {
+      return ensureStored().data[key] as T | undefined;
+    },
+
+    set(key: string, value: unknown): void {
+      const stored = ensureStored();
+      stored.data[key] = value;
+      stored.expiresAt = Date.now() + ttlMs;
+    },
+
+    has(key: string): boolean {
+      return Object.prototype.hasOwnProperty.call(ensureStored().data, key);
+    },
+
+    forget(key: string): void {
+      const stored = ensureStored();
+      stored.data = withoutKey(stored.data, key);
+      stored.expiresAt = Date.now() + ttlMs;
+    },
+
+    all(): SessionData {
+      return { ...ensureStored().data };
+    },
+
+    clear(): void {
+      const stored = ensureStored();
+      stored.data = {};
+      stored.expiresAt = Date.now() + ttlMs;
+    },
+  };
+}
+
+export const SessionManager = Object.freeze({
+  create(options: SessionManagerOptions = {}): ISessionManager {
+    const config = { ...DEFAULT_OPTIONS, ...options };
+    const sessions = new Map<string, StoredSession>();
+
+    return {
+      getIdFromCookieHeader(cookieHeader: string | undefined): string | undefined {
+        if (cookieHeader === undefined || cookieHeader.length === 0) return undefined;
+        const cookies = parseCookies(cookieHeader);
+        return cookies[config.cookieName];
+      },
+
+      getIdFromRequest(req): string | undefined {
+        const cookieHeader = req.getHeader('cookie');
+        if (typeof cookieHeader === 'string') {
+          const fromCookie = this.getIdFromCookieHeader(cookieHeader);
+          if (fromCookie !== undefined) return fromCookie;
+        }
+
+        const fromHeader = req.getHeader(config.headerName);
+        if (typeof fromHeader === 'string' && fromHeader.length > 0) return fromHeader;
+
+        if (typeof req.sessionId === 'string' && req.sessionId.length > 0) return req.sessionId;
+
+        const fromContext = req.context?.['sessionId'];
+        if (typeof fromContext === 'string' && fromContext.length > 0) return fromContext;
+
+        return undefined;
+      },
+
+      async ensureSessionId(req, res): Promise<string> {
+        const existing = this.getIdFromRequest(req);
+        const sessionId =
+          existing ??
+          (await Promise.resolve(
+            generateSecureJobId(
+              'SessionManager: secure crypto API not available to generate a session id'
+            )
+          ));
+
+        req.context['sessionId'] = sessionId;
+
+        // If the cookie is missing, set it.
+        const cookieHeader = req.getHeader('cookie');
+        const fromCookie =
+          typeof cookieHeader === 'string' ? this.getIdFromCookieHeader(cookieHeader) : undefined;
+        if (fromCookie === undefined) {
+          appendSetCookie(res, buildSessionCookie(config.cookieName, sessionId));
+        }
+
+        return sessionId;
+      },
+
+      get(sessionId: string): ISession {
+        return createSessionApi(sessions, sessionId, config.ttlMs);
+      },
+
+      destroy(sessionId: string): void {
+        sessions.delete(sessionId);
+      },
+
+      cleanup(): number {
+        const now = Date.now();
+        let removed = 0;
+
+        for (const [id, stored] of sessions.entries()) {
+          if (stored.expiresAt <= now) {
+            sessions.delete(id);
+            removed++;
+          }
+        }
+
+        return removed;
+      },
+    };
+  },
+});
+
+export default SessionManager;

package/src/session/index.ts

@@ -0,0 +1,2 @@
+export { SessionManager } from '@session/SessionManager';
+export type { ISession, ISessionManager, SessionData, SessionManagerOptions } from '@session/SessionManager';

package/src/start.ts

@@ -0,0 +1,68 @@
+import { ZintrustLang } from '@/lang/lang';
+
+const isNodeRuntime = (): boolean => {
+  // Avoid importing any `node:*` modules so this file remains Worker-safe.
+  // In Workers/Deno, `process` is typically undefined.
+
+  return (
+    typeof process !== ZintrustLang.UNDEFINED &&
+    typeof process === ZintrustLang.OBJECT &&
+    process !== null &&
+    typeof (process as unknown as { versions?: unknown }).versions === ZintrustLang.OBJECT
+  );
+};
+
+const fileUrlToPathLike = (value: string): string => {
+  if (!value.startsWith(ZintrustLang.FILE_PROTOCOL)) return value;
+  // Basic file URL decoding (sufficient for macOS/Linux paths).
+  try {
+    return decodeURIComponent(value.slice(ZintrustLang.FILE_PROTOCOL.length));
+  } catch {
+    return value.slice(ZintrustLang.FILE_PROTOCOL.length);
+  }
+};
+
+export const isNodeMain = (importMetaUrl: string): boolean => {
+  if (!isNodeRuntime()) return false;
+
+  const argv1 = (process as unknown as { argv?: unknown }).argv;
+  const scriptPath = Array.isArray(argv1) ? String(argv1[1] ?? '') : '';
+  if (scriptPath === '') return false;
+
+  const here = fileUrlToPathLike(importMetaUrl);
+  if (scriptPath === here) return true;
+
+  // Best-effort: handle relative argv paths and runner wrappers.
+  return scriptPath.endsWith(here);
+};
+
+/**
+ * Start the Node server (dev/prod) by delegating to the framework bootstrap.
+ *
+ * This uses a non-literal dynamic import so Worker bundlers don't pull Node-only modules.
+ */
+export const start = async (): Promise<void> => {
+  if (!isNodeRuntime()) return;
+
+  // Compiled output places bootstrap at `dist/src/boot/bootstrap.js`.
+  // This file compiles to `dist/src/start.js`, so relative import is stable.
+  // In unit tests, importing bootstrap has heavy side effects (starts server + exits).
+  await import('./boot/' + ZintrustLang.BOOTSTRAPJS);
+};
+
+/**
+ * Cloudflare Workers entry (module worker style).
+ */
+export { default } from '@functions/cloudflare';
+
+export { default as cloudflareWorker } from '@functions/cloudflare';
+
+/**
+ * Deno fetch handler.
+ */
+export { default as deno } from '@functions/deno';
+
+/**
+ * AWS Lambda handler.
+ */
+export { handler } from '@functions/lambda';