@pranshulsoni/flowwatch 1.0.0

package/dist/persistence/repositories/workflows/workflowRepository.js

@@ -0,0 +1,260 @@
+import { randomUUID } from "node:crypto";
+import { withTransaction } from "../../transaction.js";
+export async function insertWorkflow(pool, input) {
+    const workflowId = randomUUID();
+    const version = input.version ?? 1;
+    return withTransaction(pool, async (client) => {
+        const workflowResult = await client.query(`
+            INSERT INTO flowwatch_workflows (id, name, version)
+            VALUES ($1, $2, $3)
+            ON CONFLICT (name, version)
+            DO UPDATE SET updated_at = now()
+            RETURNING id, name, version
+            `, [workflowId, input.name, version]);
+        const workflow = workflowResult.rows[0];
+        const workflowSteps = [];
+        for (let i = 0; i < input.steps.length; i++) {
+            const step = input.steps[i];
+            const stepResult = await client.query(`
+                INSERT INTO flowwatch_workflow_steps (
+                    id,
+                    workflow_id,
+                    step_index,
+                    name,
+                    max_retries
+                )
+                VALUES ($1, $2, $3, $4, $5)
+                ON CONFLICT (workflow_id, step_index)
+                DO UPDATE SET
+                    name = EXCLUDED.name,
+                    max_retries = EXCLUDED.max_retries
+                RETURNING id, workflow_id, step_index, name, max_retries
+                `, [
+                randomUUID(),
+                workflow.id,
+                i,
+                step.name,
+                step.maxRetries ?? 0,
+            ]);
+            const savedStep = stepResult.rows[0];
+            workflowSteps.push({
+                id: savedStep.id,
+                workflowId: savedStep.workflow_id,
+                stepIndex: savedStep.step_index,
+                name: savedStep.name,
+                maxRetries: savedStep.max_retries,
+            });
+        }
+        return {
+            workflow,
+            steps: workflowSteps,
+        };
+    });
+}
+export async function insertWorkflowExecution(pool, input) {
+    const executionId = randomUUID();
+    return withTransaction(pool, async (client) => {
+        await client.query(`
+      INSERT INTO flowwatch_workflow_executions (
+        id,
+        workflow_id,
+        workflow_name,
+        workflow_version,
+        status,
+        input
+      )
+      VALUES ($1, $2, $3, $4, $5, $6)
+      `, [
+            executionId,
+            input.workflowId,
+            input.workflowName,
+            input.workflowVersion,
+            "queued",
+            JSON.stringify(input.input)
+        ]);
+        for (const step of input.steps) {
+            await client.query(`
+        INSERT INTO flowwatch_workflow_step_executions (
+          id,
+          execution_id,
+          workflow_step_id,
+          step_index,
+          step_name,
+          status,
+          input,
+          attempt_count,
+          max_retries
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        `, [
+                randomUUID(),
+                executionId,
+                step.workflowStepId,
+                step.stepIndex,
+                step.stepName,
+                "pending",
+                JSON.stringify(step.input),
+                0,
+                step.maxRetries
+            ]);
+        }
+        return { executionId };
+    });
+}
+export async function getWorkflowExecution(pool, executionId) {
+    const result = await pool.query(`SELECT * FROM flowwatch_workflow_executions WHERE id = $1`, [executionId]);
+    return result.rows[0];
+}
+export async function listWorkflowDefinitions(pool) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflows
+        ORDER BY name ASC, version DESC
+        `);
+    return result.rows;
+}
+export async function getLatestWorkflowDefinitionByName(pool, workflowName) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflows
+        WHERE name = $1
+        ORDER BY version DESC
+        LIMIT 1
+        `, [workflowName]);
+    return result.rows[0];
+}
+export async function listWorkflowExecutions(pool, limit = 50) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflow_executions
+        ORDER BY created_at DESC
+        LIMIT $1
+        `, [limit]);
+    return result.rows;
+}
+export async function listWorkflowExecutionsByWorkflowName(pool, workflowName, limit = 50) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflow_executions
+        WHERE workflow_name = $1
+        ORDER BY created_at DESC
+        LIMIT $2
+        `, [workflowName, limit]);
+    return result.rows;
+}
+export async function listWorkflowStepExecutionsByExecutionIds(pool, executionIds) {
+    if (executionIds.length === 0) {
+        return new Map();
+    }
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflow_step_executions
+        WHERE execution_id = ANY($1::uuid[])
+        ORDER BY execution_id ASC, step_index ASC
+        `, [executionIds]);
+    const grouped = new Map();
+    for (const row of result.rows) {
+        const existing = grouped.get(row.execution_id) || [];
+        existing.push(row);
+        grouped.set(row.execution_id, existing);
+    }
+    return grouped;
+}
+export async function listWorkflowStepsByWorkflowIds(pool, workflowIds) {
+    if (workflowIds.length === 0) {
+        return new Map();
+    }
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflow_steps
+        WHERE workflow_id = ANY($1::uuid[])
+        ORDER BY workflow_id ASC, step_index ASC
+        `, [workflowIds]);
+    const grouped = new Map();
+    for (const row of result.rows) {
+        const existing = grouped.get(row.workflow_id) || [];
+        existing.push({
+            id: row.id,
+            workflowId: row.workflow_id,
+            stepIndex: row.step_index,
+            name: row.name,
+            maxRetries: row.max_retries,
+        });
+        grouped.set(row.workflow_id, existing);
+    }
+    return grouped;
+}
+export async function getWorkflowExecutionSteps(pool, executionId) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_workflow_step_executions
+        WHERE execution_id = $1
+        ORDER BY step_index ASC
+        `, [executionId]);
+    return result.rows;
+}
+export async function markWorkflowExecutionRunning(pool, executionId) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_executions
+        SET status = 'running',
+            started_at = COALESCE(started_at, now())
+        WHERE id = $1
+        `, [executionId]);
+}
+export async function markWorkflowExecutionCompleted(pool, executionId, output) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_executions
+        SET status = 'completed',
+            output = $2,
+            completed_at = now()
+        WHERE id = $1
+        `, [executionId, JSON.stringify(output)]);
+}
+export async function markWorkflowExecutionFailed(pool, executionId, error) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_executions
+        SET status = 'failed',
+            error = $2,
+            failed_at = now()
+        WHERE id = $1
+        `, [executionId, JSON.stringify(serializeError(error))]);
+}
+export async function markWorkflowStepRunning(pool, stepExecutionId) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_step_executions
+        SET status = 'running',
+            started_at = COALESCE(started_at, now())
+        WHERE id = $1
+        `, [stepExecutionId]);
+}
+export async function markWorkflowStepCompleted(pool, stepExecutionId, output) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_step_executions
+        SET status = 'completed',
+            output = $2,
+            completed_at = now()
+        WHERE id = $1
+        `, [stepExecutionId, JSON.stringify(output)]);
+}
+export async function markWorkflowStepFailed(pool, stepExecutionId, error) {
+    await pool.query(`
+        UPDATE flowwatch_workflow_step_executions
+        SET status = 'failed',
+            error = $2,
+            failed_at = now(),
+            attempt_count = attempt_count + 1
+        WHERE id = $1
+        `, [stepExecutionId, JSON.stringify(serializeError(error))]);
+}
+function serializeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return {
+        message: String(error),
+    };
+}

package/dist/persistence/transaction.d.ts

@@ -0,0 +1,2 @@
+import type { Pool, PoolClient } from "pg";
+export declare function withTransaction<T>(pool: Pool, fn: (client: PoolClient) => Promise<T>): Promise<T>;

package/dist/persistence/transaction.js

@@ -0,0 +1,16 @@
+export async function withTransaction(pool, fn) {
+    const client = await pool.connect();
+    try {
+        await client.query("BEGIN");
+        const result = await fn(client);
+        await client.query("COMMIT");
+        return result;
+    }
+    catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+}

package/dist/runtime/config/normalizeConfig.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedFlowwatchConfig, FlowwatchConfig } from "../../types/index.js";
+export declare function normalizeConfig(config: FlowwatchConfig): Promise<NormalizedFlowwatchConfig>;

package/dist/runtime/config/normalizeConfig.js

@@ -0,0 +1,46 @@
+export async function normalizeConfig(config) {
+    const workerConfig = normalizeWorkerConfig(config.worker);
+    return {
+        db: config.db,
+        redis: {
+            url: config.redis.url,
+        },
+        elasticsearch: {
+            node: config.elasticsearch.node,
+        },
+        dashboard: {
+            path: config.dashboard?.path ?? "/flowwatch",
+            enabled: config.dashboard?.enabled ?? true,
+            token: config.dashboard?.token,
+            auth: config.dashboard?.auth,
+        },
+        worker: workerConfig,
+        migrations: {
+            autoRun: config.migrations?.autoRun ?? false,
+            tableName: config.migrations?.tableName ?? "flowwatch_migrations",
+        },
+        runtime: {
+            environment: config.runtime?.environment ?? process.env.NODE_ENV ?? "development",
+            serviceName: config.runtime?.serviceName ?? "flowwatch",
+            debug: config.runtime?.debug ?? false,
+        },
+    };
+}
+function normalizeWorkerConfig(worker) {
+    if (typeof worker === "boolean") {
+        return {
+            enabled: worker,
+            workflowConcurrency: 5,
+            errorIndexingConcurrency: 2,
+            maintenanceConcurrency: 1,
+            queuePrefix: "flowwatch",
+        };
+    }
+    return {
+        enabled: worker?.enabled ?? true,
+        workflowConcurrency: worker?.workflowConcurrency ?? 5,
+        errorIndexingConcurrency: worker?.errorIndexingConcurrency ?? 2,
+        maintenanceConcurrency: worker?.maintenanceConcurrency ?? 1,
+        queuePrefix: worker?.queuePrefix ?? "flowwatch",
+    };
+}

package/dist/runtime/config/validationConfig.d.ts

@@ -0,0 +1,2 @@
+import type { FlowwatchConfig } from "../../types/index.js";
+export declare function validateConfig(config: unknown): FlowwatchConfig;

package/dist/runtime/config/validationConfig.js

@@ -0,0 +1,119 @@
+export function validateConfig(config) {
+    if (!isObject(config)) {
+        throw new Error("config must be an object");
+    }
+    validateDbConfig(config.db);
+    validateRedisConfig(config.redis);
+    validateElasticsearchConfig(config.elasticsearch);
+    validateDashboardConfig(config.dashboard);
+    validateWorkerConfig(config.worker);
+    validateMigrationsConfig(config.migrations);
+    validateRuntimeConfig(config.runtime);
+    return config;
+}
+function validateDbConfig(db) {
+    if (!isObject(db)) {
+        throw new Error("config db must be an object");
+    }
+}
+function validateRedisConfig(redis) {
+    if (!isObject(redis)) {
+        throw new Error("config redis must be an object");
+    }
+    if (!isNonEmptyString(redis.url)) {
+        throw new Error("config redis.url must be a non-empty string");
+    }
+}
+function validateElasticsearchConfig(elasticsearch) {
+    if (!isObject(elasticsearch)) {
+        throw new Error("config elasticsearch must be an object");
+    }
+    if (!isNonEmptyString(elasticsearch.node)) {
+        throw new Error("config elasticsearch.node must be a non-empty string");
+    }
+}
+function validateDashboardConfig(dashboard) {
+    if (dashboard === undefined) {
+        return;
+    }
+    if (!isObject(dashboard)) {
+        throw new Error("config dashboard must be an object");
+    }
+    if (dashboard.path !== undefined && (!isNonEmptyString(dashboard.path) || !dashboard.path.startsWith("/"))) {
+        throw new Error("config dashboard.path must be a non-empty string starting with /");
+    }
+    if (dashboard.token !== undefined && !isNonEmptyString(dashboard.token)) {
+        throw new Error("config dashboard.token must be a non-empty string");
+    }
+    if (dashboard.auth !== undefined && typeof dashboard.auth !== "function") {
+        throw new Error("config dashboard.auth must be a function");
+    }
+    if (dashboard.enabled !== undefined && typeof dashboard.enabled !== "boolean") {
+        throw new Error("config dashboard.enabled must be a boolean");
+    }
+}
+function validateWorkerConfig(worker) {
+    if (worker === undefined) {
+        return;
+    }
+    if (typeof worker === "boolean") {
+        return;
+    }
+    if (!isObject(worker)) {
+        throw new Error("config worker must be a boolean or an object");
+    }
+    if (worker.enabled !== undefined && typeof worker.enabled !== "boolean") {
+        throw new Error("config worker.enabled must be a boolean");
+    }
+    validatePositiveInteger(worker.workflowConcurrency, "worker.workflowConcurrency");
+    validatePositiveInteger(worker.errorIndexingConcurrency, "worker.errorIndexingConcurrency");
+    validatePositiveInteger(worker.maintenanceConcurrency, "worker.maintenanceConcurrency");
+    if (worker.queuePrefix !== undefined && !isNonEmptyString(worker.queuePrefix)) {
+        throw new Error("config worker.queuePrefix must be a non-empty string");
+    }
+}
+function validateMigrationsConfig(migrations) {
+    if (migrations === undefined) {
+        return;
+    }
+    if (!isObject(migrations)) {
+        throw new Error("config migrations must be an object");
+    }
+    if (migrations.autoRun !== undefined && typeof migrations.autoRun !== "boolean") {
+        throw new Error("config migrations.autoRun must be a boolean");
+    }
+    if (migrations.tableName !== undefined && !isNonEmptyString(migrations.tableName)) {
+        throw new Error("config migrations.tableName must be a non-empty string");
+    }
+}
+function validateRuntimeConfig(runtime) {
+    if (runtime === undefined) {
+        return;
+    }
+    if (!isObject(runtime)) {
+        throw new Error("config runtime must be an object");
+    }
+    if (runtime.environment !== undefined && !isNonEmptyString(runtime.environment)) {
+        throw new Error("config runtime.environment must be a non-empty string");
+    }
+    if (runtime.serviceName !== undefined && !isNonEmptyString(runtime.serviceName)) {
+        throw new Error("config runtime.serviceName must be a non-empty string");
+    }
+    if (runtime.debug !== undefined && typeof runtime.debug !== "boolean") {
+        throw new Error("config runtime.debug must be a boolean");
+    }
+}
+function validatePositiveInteger(value, fieldName) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`config ${fieldName} must be a positive integer`);
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/runtime/health/healthService.d.ts

@@ -0,0 +1,30 @@
+import type { Client } from "@elastic/elasticsearch";
+import type { Pool } from "pg";
+import type { Redis } from "ioredis";
+export declare function checkPostgresHealth(pool: Pool): Promise<{
+    status: string;
+    latencyMs: number;
+    message?: undefined;
+} | {
+    status: string;
+    message: string;
+    latencyMs?: undefined;
+}>;
+export declare function checkRedisHealth(redisClient: Redis): Promise<{
+    status: string;
+    message: string;
+    latencyMs?: undefined;
+} | {
+    status: string;
+    latencyMs: number;
+    message?: undefined;
+}>;
+export declare function checkElasticsearchHealth(elasticsearchClient: Client): Promise<{
+    status: string;
+    latencyMs: number;
+    message?: undefined;
+} | {
+    status: string;
+    message: string;
+    latencyMs?: undefined;
+}>;

package/dist/runtime/health/healthService.js

@@ -0,0 +1,54 @@
+export async function checkPostgresHealth(pool) {
+    const startedAt = Date.now();
+    try {
+        await pool.query("SELECT 1");
+        return {
+            status: "ok",
+            latencyMs: Date.now() - startedAt
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : "Unknown error"
+        };
+    }
+}
+export async function checkRedisHealth(redisClient) {
+    const startedAt = Date.now();
+    try {
+        const response = await redisClient.ping();
+        if (response != "PONG") {
+            return {
+                status: "error",
+                message: `Unexpected Redis Response ${response}`
+            };
+        }
+        return {
+            status: "ok",
+            latencyMs: Date.now() - startedAt
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : "Unknown error"
+        };
+    }
+}
+export async function checkElasticsearchHealth(elasticsearchClient) {
+    const startedAt = Date.now();
+    try {
+        await elasticsearchClient.ping();
+        return {
+            status: "ok",
+            latencyMs: Date.now() - startedAt
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : "Unknown error"
+        };
+    }
+}

package/dist/runtime/tracing/traceContext.d.ts

@@ -0,0 +1,12 @@
+export interface TraceContext {
+    traceId: string;
+    currentSpanId?: string;
+    userId?: string;
+    ip?: string;
+}
+export declare function runWithTraceContext<T>(context: TraceContext, callback: () => T): T;
+export declare function getCurrentTraceContext(): TraceContext | undefined;
+export declare function getCurrentClientIp(): string | undefined;
+export declare function getCurrentTraceId(): string | undefined;
+export declare function getCurrentSpanId(): string | undefined;
+export declare function runWithSpanContext<T>(spanId: string, callback: () => T): T;

package/dist/runtime/tracing/traceContext.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const traceStorage = new AsyncLocalStorage();
+//Added a generic class named async local storage with the type tracecontext, as its a generic class all its methods also return the generic type.
+export function runWithTraceContext(context, callback) {
+    return traceStorage.run(context, callback);
+}
+export function getCurrentTraceContext() {
+    return traceStorage.getStore();
+}
+export function getCurrentClientIp() {
+    return traceStorage.getStore()?.ip;
+}
+export function getCurrentTraceId() {
+    return traceStorage.getStore()?.traceId;
+}
+export function getCurrentSpanId() {
+    return traceStorage.getStore()?.currentSpanId;
+}
+export function runWithSpanContext(spanId, callback) {
+    const currentContext = traceStorage.getStore();
+    if (!currentContext) {
+        return callback();
+    }
+    return traceStorage.run({
+        ...currentContext,
+        currentSpanId: spanId,
+    }, callback);
+}

package/dist/runtime/tracing/tracingMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { RequestHandler } from "express";
+import type { Pool } from "pg";
+export declare function createRequestTracingMiddleware(pool: Pool): RequestHandler;

package/dist/runtime/tracing/tracingMiddleware.js

@@ -0,0 +1,46 @@
+import { createRequestTrace, finishRequestTrace } from "../../persistence/repositories/traces/traceRepository.js";
+import { runWithTraceContext } from "./traceContext.js";
+export function createRequestTracingMiddleware(pool) {
+    return async function requestTracingMiddleware(req, res, next) {
+        const startedAt = Date.now();
+        const clientIp = getClientIp(req);
+        try {
+            const trace = await createRequestTrace(pool, {
+                method: req.method,
+                path: req.originalUrl || req.path,
+                ip: clientIp,
+            });
+            res.on("finish", () => {
+                finishRequestTrace(pool, {
+                    traceId: trace.id,
+                    statusCode: res.statusCode,
+                    durationMs: Date.now() - startedAt,
+                }).catch(() => {
+                });
+            });
+            runWithTraceContext({ traceId: trace.id, ip: clientIp, }, next);
+        }
+        catch {
+            next();
+        }
+    };
+}
+function getClientIp(req) {
+    const forwardedFor = req.get("x-forwarded-for");
+    if (forwardedFor) {
+        return normalizeClientIp(forwardedFor.split(",")[0]?.trim());
+    }
+    return normalizeClientIp(req.ip || req.socket.remoteAddress || undefined);
+}
+function normalizeClientIp(value) {
+    if (!value)
+        return undefined;
+    const ip = value.trim();
+    if (ip === "::1" || ip === "::ffff:127.0.0.1") {
+        return "127.0.0.1";
+    }
+    if (ip.startsWith("::ffff:")) {
+        return ip.slice("::ffff:".length);
+    }
+    return ip;
+}

package/dist/search/elasticsearch/client.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "@elastic/elasticsearch";
+export declare function createElasticsearchClient(node: string): Client;

package/dist/search/elasticsearch/client.js

@@ -0,0 +1,4 @@
+import { Client } from "@elastic/elasticsearch";
+export function createElasticsearchClient(node) {
+    return new Client({ node });
+}

package/dist/search/elasticsearch/indexSetup.d.ts

@@ -0,0 +1,3 @@
+import type { Client } from "@elastic/elasticsearch";
+export declare function createErrorMapping(client: Client): Promise<void>;
+export declare function createTraceMapping(client: Client): Promise<void>;