@eventmodelers/cli 0.0.1

package/stacks/node/templates/root/server.ts

@@ -0,0 +1,130 @@
+import {join} from 'path';
+import {getApplication, startAPI, WebApiSetup} from '@event-driven-io/emmett-expressjs';
+import {glob} from "glob";
+import express, {Application, Request, Response} from 'express';
+import {jsonBigIntReplacer} from './src/util/sanitize';
+import {closeDb} from "./src/common/db";
+import swaggerUi from 'swagger-ui-express'
+import {specs} from './src/swagger';
+import cors from 'cors';
+import {findEventstore} from "./src/common/loadPostgresEventstore";
+import {PostgresEventStore} from "@event-driven-io/emmett-postgresql";
+
+async function startServer() {
+
+    const eventStore = await findEventstore()
+    const slicesBase = join(__dirname, 'dist/src/slices');
+    const routesPattern = join(slicesBase, '**/routes{,-*}.js');
+
+    const routeFiles = await glob(routesPattern, {nodir: true});
+    console.log('Found route files:', routeFiles);
+
+    const processorPattern = join(slicesBase, '**/processor{,-*}.js');
+    const processorFiles = await glob(processorPattern, {nodir: true});
+    console.log('Found processor files:', processorFiles);
+
+    const commonPattern = join(__dirname, 'src/common/routes{,-*}.@(ts|js)');
+    const commonRouteFiles = await glob(commonPattern, {nodir: true});
+    console.log('Found common route files:', commonRouteFiles);
+
+
+    const rootApp: Application = express();
+    rootApp.set('json replacer', jsonBigIntReplacer);
+
+    const corsOrigins = process.env.CORS_ORIGINS?.split(',').map(o => o.trim()) ?? ['http://localhost:3000', 'http://localhost:3001'];
+    rootApp.use(cors({
+        origin: corsOrigins,
+        credentials: true,
+        methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Content-Encoding',  'accept-encoding', 'Authorization','x-user-id','x-causation-id','x-correlation-id']
+    }));
+
+    const webApis: WebApiSetup[] = [];
+
+    for (const file of routeFiles.concat(commonRouteFiles)) {
+        const webApiModule: { api: () => WebApiSetup } = await import(file);
+        if (typeof webApiModule.api == 'function') {
+            var module = webApiModule.api()
+            webApis.push(module);
+        } else {
+            console.error(`Expected api function to be defined in ${file}`);
+        }
+    }
+
+    const startedProcessors: Array<{ stop: () => Promise<void> }> = [];
+
+    for (const processorFile of processorFiles) {
+        const processor: { processor: { start: (eventStore: PostgresEventStore) => Promise<void>; stop: () => Promise<void> } } = await import(processorFile);
+        if (typeof processor.processor.start == "function") {
+            console.log(`starting processor ${processorFile}`)
+            processor.processor.start(eventStore).catch(err => console.error(`Processor ${processorFile} failed:`, err));
+            startedProcessors.push(processor.processor);
+        }
+    }
+
+    const shutdown = async (signal: string) => {
+        console.log(`${signal} received, shutting down processors...`);
+        await Promise.allSettled(startedProcessors.map(p => p.stop()));
+        await eventStore.close();
+        await closeDb();
+        console.log('shutdown complete');
+        process.exit(0);
+    };
+
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+    // Get the main application from emmett
+    const childApp: Application = getApplication({
+        apis: webApis,
+        disableJsonMiddleware: false,
+        enableDefaultExpressEtag: true,
+    });
+    childApp.set('json replacer', jsonBigIntReplacer);
+
+    // Swagger UI endpoints
+    childApp.use('/api-docs', swaggerUi.serve);
+    childApp.get('/api-docs', swaggerUi.setup(specs, {
+        swaggerOptions: {
+            urls: [
+                {
+                    url: '/swagger.json',
+                    name: 'JSON',
+                },
+            ],
+        },
+    }));
+
+    // OpenAPI spec endpoint
+    childApp.get('/swagger.json', (req: Request, res: Response) => {
+        res.setHeader('Content-Type', 'application/json');
+        res.send(specs);
+    });
+
+    const port = parseInt(process.env.PORT || '3000', 10);
+    console.log(`> Ready on port ${port}`);
+
+    rootApp.use((req: Request, _res: Response, next) => {
+        console.log(`[${req.method}] ${req.path}`);
+        next();
+    });
+
+    rootApp.use(express.json());
+
+
+    rootApp.use(childApp)
+    // Start the main application
+    startAPI(rootApp, {port: port});
+
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('⛔ Unhandled Rejection:', reason);
+        if (reason instanceof Error && reason.stack) {
+            console.error('Stack trace:\n', reason.stack);
+        }
+    });
+}
+
+startServer().catch(error => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});

package/stacks/node/templates/root/setup-env.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+prompt() {
+  local var_name="$1"
+  local prompt_text="$2"
+  local value
+  read -rp "$prompt_text: " value
+  if [[ -z "$value" ]]; then
+    echo "Error: $var_name cannot be empty." >&2
+    exit 1
+  fi
+  echo "$value"
+}
+
+prompt_secret() {
+  local var_name="$1"
+  local prompt_text="$2"
+  local value
+  read -rsp "$prompt_text: " value
+  echo "" >&2
+  if [[ -z "$value" ]]; then
+    echo "Error: $var_name cannot be empty." >&2
+    exit 1
+  fi
+  echo "$value"
+}
+
+echo "=== Postgres .env setup ==="
+echo ""
+
+DB_HOST=$(prompt DB_HOST "Postgres host (e.g. localhost)")
+DB_PORT=$(prompt DB_PORT "Postgres port (e.g. 5432)")
+DB_NAME=$(prompt DB_NAME "Database name (e.g. postgres)")
+DB_USER=$(prompt DB_USER "Database user (e.g. postgres)")
+DB_PASSWORD=$(prompt_secret DB_PASSWORD "Database password")
+BACKEND_URL=$(prompt BACKEND_URL "Backend URL (e.g. http://localhost:3000)")
+
+cat > .env <<EOF
+DATABASE_URL=postgresql://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?prepareThreshold=0
+
+BACKEND_URL=${BACKEND_URL}
+PORT=3000
+API_URL=${BACKEND_URL}
+
+# Flyway configuration
+FLYWAY_URL=jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
+FLYWAY_USER=${DB_USER}
+FLYWAY_PASSWORD=${DB_PASSWORD}
+EOF
+
+echo ""
+echo ".env created successfully."

package/stacks/node/templates/root/src/common/assertions.ts

@@ -0,0 +1,6 @@
+export function assertNotEmpty<T>(value: T): NonNullable<T> {
+    if (value === null || value === undefined) {
+        throw new Error("Expected non-empty value");
+    }
+    return value!!;
+}

package/stacks/node/templates/root/src/common/db.ts

@@ -0,0 +1,32 @@
+import knex, {Knex} from "knex";
+import pg from "pg";
+
+export const postgresUrl = process.env.DATABASE_URL ?? "missing-url"
+
+let knexInstance: Knex | null = null;
+let sharedPool: pg.Pool | null = null;
+
+export const getKnexInstance = (): Knex => {
+    if (!knexInstance) {
+        knexInstance = knex({
+            client: 'pg',
+            connection: postgresUrl,
+            pool: { min: 0, max: 5 },
+        });
+    }
+    return knexInstance;
+};
+
+export const getSharedPool = (): pg.Pool => {
+    if (!sharedPool) {
+        sharedPool = new pg.Pool({ connectionString: postgresUrl, max: 5 });
+    }
+    return sharedPool;
+};
+
+export const closeDb = async (): Promise<void> => {
+    await knexInstance?.destroy();
+    await sharedPool?.end();
+    knexInstance = null;
+    sharedPool = null;
+};

package/stacks/node/templates/root/src/common/loadPostgresEventstore.ts

@@ -0,0 +1,23 @@
+import {getPostgreSQLEventStore} from "@event-driven-io/emmett-postgresql";
+import {projections} from "@event-driven-io/emmett";
+import {postgresUrl, getSharedPool} from "./db";
+
+let eventStoreInstance: ReturnType<typeof getPostgreSQLEventStore> | null = null;
+
+export const findEventstore = async () => {
+    if (!eventStoreInstance) {
+        eventStoreInstance = getPostgreSQLEventStore(postgresUrl, {
+            schema: {
+                autoMigration: "CreateOrUpdate"
+            },
+            connectionOptions: {
+                pooled: true,
+                pool: getSharedPool(),
+            },
+            projections: projections.inline([
+            ]),
+        });
+        await eventStoreInstance.schema.migrate();
+    }
+    return eventStoreInstance;
+};

package/stacks/node/templates/root/src/common/parseEndpoint.ts

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2025 Nebulit GmbH
+ * Licensed under the MIT License.
+ */
+
+const serviceURI = "http://localhost:3000"
+
+export function parseEndpoint(endpoint: string, data?: any) {
+    var parsedEndpoint = endpoint?.startsWith("/") ? endpoint.substring(1) : endpoint
+    return serviceURI + "/" + lowercaseFirstCharacter(parsedEndpoint).replace(/{(\w+)}/g, (match, param) => {
+        return param && data && data[param] !== undefined ? data[param] : match;
+    })
+}
+
+
+export function parseQueryEndpoint(
+    endpoint: string,
+    queries?: Record<string, string>
+) {
+    const parsedEndpoint = endpoint.startsWith("/")
+        ? endpoint.substring(1)
+        : endpoint;
+
+    const basePath =
+        serviceURI + "/api/query/" + parsedEndpoint;
+
+    const queryString = queries
+        ? "?" + new URLSearchParams(filterEmptyEntries(queries)).toString()
+        : "";
+
+    return basePath + queryString;
+}
+
+function filterEmptyEntries(queries?: Record<string, string>): Record<string, string> {
+    if (!queries) return {};
+    return Object.fromEntries(
+        Object.entries(queries).filter(([key, value]) => value !== "")
+    );
+}
+
+
+function lowercaseFirstCharacter(inputString: string) {
+    // Check if the string is not empty
+    if (inputString?.length > 0) {
+        // Capitalize the first character and concatenate the rest of the string
+        return inputString.charAt(0).toLowerCase() + inputString.substring(1);
+    } else {
+        // Return an empty string if the input is empty
+        return "";
+    }
+}

package/stacks/node/templates/root/src/common/processorDlq.ts

@@ -0,0 +1,28 @@
+import {getKnexInstance} from './db';
+import type {AnyRecordedMessageMetadata, RecordedMessage} from '@event-driven-io/emmett';
+
+export const storeDlqMessage = async (
+    processorId: string,
+    message: RecordedMessage<any, AnyRecordedMessageMetadata>,
+    error: unknown,
+): Promise<void> => {
+
+    try {
+        console.log(`Processing DLQ ${JSON.stringify({ type: message.type, data: message.data, metadata: message.metadata } , (key, value) =>
+            typeof value === 'bigint' ? value.toString() : value
+        )}`)
+        await getKnexInstance()('processor_dlq').insert({
+            processor_id: processorId,
+            stream_id: message.metadata.streamName,
+            event:  JSON.parse(
+                JSON.stringify({ type: message.type, data: message.data, metadata: message.metadata } , (key, value) =>
+                    typeof value === 'bigint' ? value.toString() : value
+                )
+            ),
+            error: error instanceof Error ? error.message : String(error),
+        });
+    } catch (dlqError) {
+        console.error('Failed to write to processor_dlq:', dlqError);
+    }
+};
+

package/stacks/node/templates/root/src/common/realtimeBroadcast.ts

@@ -0,0 +1,12 @@
+const clients = new Set<(event: string, payload: unknown) => void>();
+
+export function subscribeRealtime(handler: (event: string, payload: unknown) => void): () => void {
+    clients.add(handler);
+    return () => clients.delete(handler);
+}
+
+export async function broadcastRealtime(topic: string, event: string, payload: unknown): Promise<void> {
+    for (const handler of clients) {
+        handler(event, payload);
+    }
+}

package/stacks/node/templates/root/src/common/replay.ts

@@ -0,0 +1,16 @@
+import {PostgreSQLProjectionDefinition, rebuildPostgreSQLProjections} from "@event-driven-io/emmett-postgresql";
+import {postgresUrl} from "./db";
+import {glob} from "glob";
+import path from "path";
+
+const slicesRoot = path.resolve(__dirname, '../slices');
+
+export const replayProjection = async (projectionName: string): Promise<void> => {
+    const [filePath] = await glob(`**/${projectionName}.{ts|js}`, {cwd: slicesRoot, absolute: true});
+    if (!filePath) throw new Error(`Projection not found: ${projectionName}`);
+
+    const projectionImport = await import(filePath);
+    const projection: PostgreSQLProjectionDefinition = projectionImport[projectionName];
+
+    return rebuildPostgreSQLProjections({projection, connectionString: postgresUrl}).start();
+}

package/stacks/node/templates/root/src/common/routes.ts

@@ -0,0 +1,19 @@
+import {Request, Response, Router} from 'express';
+import {WebApiSetup} from "@event-driven-io/emmett-expressjs";
+import {assertNotEmpty} from "../util/assertions";
+import {replayProjection} from "./replay";
+
+
+export const api =
+    (
+        // external dependencies
+    ): WebApiSetup =>
+        (router: Router): void => {
+
+            router.post('/api/replay/:projection', async (req: Request, res: Response) => {
+                const projection = assertNotEmpty(req.params.projection)
+                await replayProjection(projection)
+                res.status(200).json({"projection":projection})
+            });
+        };
+

package/stacks/node/templates/root/src/common/testHelpers.ts

@@ -0,0 +1,44 @@
+import {execSync} from 'child_process';
+import {writeFileSync, unlinkSync} from 'fs';
+import {tmpdir} from 'os';
+import {join} from 'path';
+
+export async function runFlywayMigrations(connectionString: string): Promise<void> {
+    const url = new URL(connectionString);
+    const jdbcUrl = `jdbc:postgresql://${url.hostname}:${url.port || 5432}${url.pathname}`;
+    const user = url.username;
+    const password = url.password;
+
+    const tempConfigPath = join(tmpdir(), `flyway-test-${Date.now()}.conf`);
+    const migrationsPath = join(process.cwd(), 'migrations');
+
+    const config = `
+flyway.url=${jdbcUrl}
+flyway.user=${user}
+flyway.password=${password}
+flyway.locations=filesystem:${migrationsPath}
+flyway.schemas=public
+flyway.placeholderReplacement=false
+flyway.validateOnMigrate=true
+flyway.cleanDisabled=false
+`;
+
+    try {
+        writeFileSync(tempConfigPath, config, 'utf8');
+        execSync(`flyway -configFiles=${tempConfigPath} migrate`, {
+            stdio: 'pipe',
+            encoding: 'utf8'
+        });
+    } catch (error: any) {
+        console.error('Flyway migration failed:', error.message);
+        if (error.stdout) console.error('STDOUT:', error.stdout);
+        if (error.stderr) console.error('STDERR:', error.stderr);
+        throw new Error(`Flyway migration failed: ${error.message}`);
+    } finally {
+        try {
+            unlinkSync(tempConfigPath);
+        } catch {
+            // ignore
+        }
+    }
+}

package/stacks/node/templates/root/src/swagger.ts

@@ -0,0 +1,34 @@
+import swaggerJsdoc from 'swagger-jsdoc';
+
+const options = {
+    definition: {
+        openapi: '3.0.0',
+        info: {
+            title: 'Context API',
+            version: '1.0.0',
+            description: 'Event-driven API for shift, clerk, and task management',
+        },
+        servers: [
+            {
+                url: 'http://localhost:3000',
+                description: 'Development server',
+            },
+            {
+                url: process.env.API_URL || 'http://localhost:3000',
+                description: 'Production server',
+            },
+        ],
+        components: {
+            securitySchemes: {
+                bearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                    bearerFormat: 'JWT',
+                },
+            },
+        },
+    },
+    apis: ['./src/slices/**/routes.ts'],
+};
+
+export const specs = swaggerJsdoc(options);

package/stacks/node/templates/root/src/util/assertions.ts

@@ -0,0 +1,6 @@
+export function assertNotEmpty<T>(value: T): NonNullable<T> {
+    if (value === null || value === undefined) {
+        throw new Error("Expected non-empty value");
+    }
+    return value!!;
+}

package/stacks/node/templates/root/src/util/hash.ts

@@ -0,0 +1,9 @@
+// Fast djb2-style hash of any object — used to detect drift
+export function hashMeta(entry: unknown): string {
+    const str = JSON.stringify(entry);
+    let h = 5381;
+    for (let i = 0; i < str.length; i++) {
+        h = (((h << 5) + h) ^ str.charCodeAt(i)) >>> 0;
+    }
+    return h.toString(36);
+}

package/stacks/node/templates/root/src/util/sanitize.ts

@@ -0,0 +1,23 @@
+function sanitizeValue(value: unknown): unknown {
+    if (typeof value === 'bigint') {
+        return Number.isSafeInteger(Number(value)) ? Number(value) : value.toString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(sanitizeValue);
+    }
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value).map(([k, v]) => [k, sanitizeValue(v)])
+        );
+    }
+    return value;
+}
+
+export function sanitize<T>(value: T): unknown {
+    return sanitizeValue(value);
+}
+
+export const jsonBigIntReplacer = (_key: string, value: unknown): unknown =>
+    typeof value === 'bigint'
+        ? (Number.isSafeInteger(Number(value)) ? Number(value) : value.toString())
+        : value;

package/stacks/node/templates/root/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+        "node_modules/*"
+      ]
+    },
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "lib": [
+      "es2020"
+    ],
+    "allowJs": true,
+    "incremental": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.sample",
+    "realtime-agent"
+  ]
+}

package/stacks/node/templates/root/vercel.json

@@ -0,0 +1,8 @@
+{
+  "buildCommand": "npm run build",
+  "functions": {
+    "server.js": {
+      "includeFiles": "dist/**"
+    }
+  }
+}