@pranshulsoni/flowwatch 1.0.0

package/dist/persistence/repositories/flags/flagRepository.js

@@ -0,0 +1,245 @@
+import { randomUUID } from "node:crypto";
+import { withTransaction } from "../../transaction.js";
+// ─── Flag CRUD ────────────────────────────────────────────────────────────────
+export async function createFlag(pool, input) {
+    const flagId = randomUUID();
+    return withTransaction(pool, async (client) => {
+        const result = await client.query(`
+            INSERT INTO flowwatch_feature_flags (
+                id,
+                key,
+                description,
+                enabled,
+                rollout_percentage
+            )
+            VALUES ($1, $2, $3, $4, $5)
+            RETURNING *
+            `, [
+            flagId,
+            input.key,
+            input.description ?? null,
+            input.enabled ?? false,
+            input.rolloutPercentage ?? 0,
+        ]);
+        const flag = result.rows[0];
+        await insertAuditLog(client, {
+            flagId: flag.id,
+            action: "flag_created",
+            before: null,
+            after: flag,
+            changedBy: input.changedBy,
+        });
+        return flag;
+    });
+}
+export async function listFlags(pool) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_feature_flags
+        ORDER BY key ASC
+        `);
+    return result.rows;
+}
+export async function listFlagsWithRuleCounts(pool) {
+    const result = await pool.query(`
+        SELECT flags.*, COUNT(rules.id)::int AS rule_count
+        FROM flowwatch_feature_flags flags
+        LEFT JOIN flowwatch_feature_flag_rules rules ON rules.flag_id = flags.id
+        GROUP BY flags.id
+        ORDER BY flags.key ASC
+        `);
+    return result.rows;
+}
+export async function getFlagByKey(pool, key) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_feature_flags
+        WHERE key = $1
+        `, [key]);
+    return result.rows[0];
+}
+export async function updateFlag(pool, key, input) {
+    return withTransaction(pool, async (client) => {
+        const beforeResult = await client.query(`SELECT * FROM flowwatch_feature_flags WHERE key = $1`, [key]);
+        const before = beforeResult.rows[0];
+        if (!before)
+            return undefined;
+        const result = await client.query(`
+            UPDATE flowwatch_feature_flags
+            SET description = COALESCE($2, description),
+                enabled = COALESCE($3, enabled),
+                rollout_percentage = COALESCE($4, rollout_percentage),
+                updated_at = now()
+            WHERE key = $1
+            RETURNING *
+            `, [
+            key,
+            input.description,
+            input.enabled,
+            input.rolloutPercentage,
+        ]);
+        const after = result.rows[0];
+        await insertAuditLog(client, {
+            flagId: after.id,
+            action: "flag_updated",
+            before,
+            after,
+            changedBy: input.changedBy,
+        });
+        return after;
+    });
+}
+export async function deleteFlag(pool, key, changedBy) {
+    return withTransaction(pool, async (client) => {
+        const beforeResult = await client.query(`SELECT * FROM flowwatch_feature_flags WHERE key = $1`, [key]);
+        const before = beforeResult.rows[0];
+        if (!before)
+            return false;
+        // Write audit log BEFORE delete so the FK to flowwatch_feature_flags is still valid
+        await insertAuditLog(client, {
+            flagId: before.id,
+            action: "flag_deleted",
+            before,
+            after: null,
+            changedBy,
+        });
+        await client.query(`DELETE FROM flowwatch_feature_flags WHERE key = $1`, [key]);
+        return true;
+    });
+}
+// ─── Flag Rules ───────────────────────────────────────────────────────────────
+export async function listFlagRules(pool, flagKey) {
+    const flag = await getFlagByKey(pool, flagKey);
+    if (!flag) {
+        return [];
+    }
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_feature_flag_rules
+        WHERE flag_id = $1
+        ORDER BY created_at ASC
+        `, [flag.id]);
+    return result.rows;
+}
+export async function createFlagRule(pool, input) {
+    return withTransaction(pool, async (client) => {
+        const flagResult = await client.query(`SELECT * FROM flowwatch_feature_flags WHERE key = $1`, [input.flagKey]);
+        const flag = flagResult.rows[0];
+        if (!flag)
+            return undefined;
+        const result = await client.query(`
+            INSERT INTO flowwatch_feature_flag_rules (
+                id,
+                flag_id,
+                attribute,
+                operator,
+                value,
+                enabled
+            )
+            VALUES ($1, $2, $3, $4, $5::jsonb, $6)
+            RETURNING *
+            `, [
+            randomUUID(),
+            flag.id,
+            input.attribute,
+            input.operator,
+            JSON.stringify(input.value),
+            input.enabled ?? true,
+        ]);
+        const rule = result.rows[0];
+        await insertAuditLog(client, {
+            flagId: flag.id,
+            action: "rule_created",
+            before: null,
+            after: rule,
+            changedBy: input.changedBy,
+        });
+        return rule;
+    });
+}
+export async function updateFlagRule(pool, ruleId, input) {
+    return withTransaction(pool, async (client) => {
+        const beforeResult = await client.query(`SELECT * FROM flowwatch_feature_flag_rules WHERE id = $1`, [ruleId]);
+        const before = beforeResult.rows[0];
+        if (!before)
+            return undefined;
+        const result = await client.query(`
+            UPDATE flowwatch_feature_flag_rules
+            SET attribute = COALESCE($2, attribute),
+                operator = COALESCE($3, operator),
+                value = COALESCE($4::jsonb, value),
+                enabled = COALESCE($5, enabled),
+                updated_at = now()
+            WHERE id = $1
+            RETURNING *
+            `, [
+            ruleId,
+            input.attribute,
+            input.operator,
+            input.value === undefined ? undefined : JSON.stringify(input.value),
+            input.enabled,
+        ]);
+        const after = result.rows[0];
+        await insertAuditLog(client, {
+            flagId: after.flag_id,
+            action: "rule_updated",
+            before,
+            after,
+            changedBy: input.changedBy,
+        });
+        return after;
+    });
+}
+export async function deleteFlagRule(pool, ruleId, changedBy) {
+    return withTransaction(pool, async (client) => {
+        const beforeResult = await client.query(`SELECT * FROM flowwatch_feature_flag_rules WHERE id = $1`, [ruleId]);
+        const before = beforeResult.rows[0];
+        if (!before)
+            return false;
+        // Write audit log BEFORE delete so the FK to flowwatch_feature_flag_rules is still valid
+        await insertAuditLog(client, {
+            flagId: before.flag_id,
+            action: "rule_deleted",
+            before,
+            after: null,
+            changedBy,
+        });
+        await client.query(`DELETE FROM flowwatch_feature_flag_rules WHERE id = $1`, [ruleId]);
+        return true;
+    });
+}
+// ─── Audit logs ───────────────────────────────────────────────────────────────
+export async function listFlagAuditLogs(pool, flagKey) {
+    const flag = await getFlagByKey(pool, flagKey);
+    if (!flag) {
+        return [];
+    }
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_feature_flag_audit_logs
+        WHERE flag_id = $1
+        ORDER BY created_at DESC
+        `, [flag.id]);
+    return result.rows;
+}
+// Accepts a PoolClient so audit logs share the same transaction as the main op
+async function insertAuditLog(client, input) {
+    await client.query(`
+        INSERT INTO flowwatch_feature_flag_audit_logs (
+            id,
+            flag_id,
+            action,
+            before,
+            after,
+            changed_by
+        )
+        VALUES ($1, $2, $3, $4::jsonb, $5::jsonb, $6)
+        `, [
+        randomUUID(),
+        input.flagId,
+        input.action,
+        JSON.stringify(input.before),
+        JSON.stringify(input.after),
+        input.changedBy ?? null,
+    ]);
+}

package/dist/persistence/repositories/traces/traceRepository.d.ts

@@ -0,0 +1,64 @@
+import type { Pool } from "pg";
+export type TraceSpanType = "middleware" | "service" | "repository" | "external_api" | "workflow_step" | "feature_flag" | "custom";
+export type TraceStatus = "running" | "ok" | "error";
+export interface RequestTraceRow {
+    id: string;
+    method: string;
+    path: string;
+    status_code: number | null;
+    duration_ms: number | null;
+    user_id: string | null;
+    ip: string | null;
+    user_agent: string | null;
+    metadata: unknown;
+    started_at: Date;
+    ended_at: Date | null;
+    created_at: Date;
+}
+export interface TraceSpanRow {
+    id: string;
+    trace_id: string;
+    parent_span_id: string | null;
+    name: string;
+    type: TraceSpanType;
+    status: TraceStatus;
+    duration_ms: number | null;
+    metadata: unknown;
+    started_at: Date;
+    ended_at: Date | null;
+    created_at: Date;
+}
+export interface CreateRequestTraceInput {
+    method: string;
+    path: string;
+    userId?: string;
+    ip?: string;
+    userAgent?: string;
+    metadata?: unknown;
+}
+export interface FinishRequestTraceInput {
+    traceId: string;
+    statusCode?: number;
+    durationMs: number;
+    metadata?: unknown;
+}
+export interface CreateTraceSpanInput {
+    traceId: string;
+    parentSpanId?: string;
+    name: string;
+    type: TraceSpanType;
+    metadata?: unknown;
+}
+export interface FinishTraceSpanInput {
+    spanId: string;
+    status: TraceStatus;
+    durationMs: number;
+    metadata?: unknown;
+}
+export declare function createRequestTrace(pool: Pool, input: CreateRequestTraceInput): Promise<RequestTraceRow>;
+export declare function finishRequestTrace(pool: Pool, input: FinishRequestTraceInput): Promise<RequestTraceRow | undefined>;
+export declare function createTraceSpan(pool: Pool, input: CreateTraceSpanInput): Promise<TraceSpanRow>;
+export declare function finishTraceSpan(pool: Pool, input: FinishTraceSpanInput): Promise<TraceSpanRow | undefined>;
+export declare function getRequestTrace(pool: Pool, traceId: string): Promise<RequestTraceRow | undefined>;
+export declare function listRequestTraces(pool: Pool, limit?: number): Promise<RequestTraceRow[]>;
+export declare function getTraceSpans(pool: Pool, traceId: string): Promise<TraceSpanRow[]>;

package/dist/persistence/repositories/traces/traceRepository.js

@@ -0,0 +1,110 @@
+import { randomUUID } from "node:crypto";
+export async function createRequestTrace(pool, input) {
+    const result = await pool.query(`
+        INSERT INTO flowwatch_request_traces (
+            id,
+            method,
+            path,
+            user_id,
+            ip,
+            user_agent,
+            metadata,
+            started_at
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, now())
+        RETURNING *
+        `, [
+        randomUUID(),
+        input.method,
+        input.path,
+        input.userId ?? null,
+        input.ip ?? null,
+        input.userAgent ?? null,
+        JSON.stringify(input.metadata ?? {}),
+    ]);
+    return result.rows[0];
+}
+export async function finishRequestTrace(pool, input) {
+    const result = await pool.query(`
+        UPDATE flowwatch_request_traces
+        SET status_code = COALESCE($2, status_code),
+            duration_ms = $3,
+            metadata = COALESCE($4::jsonb, metadata),
+            ended_at = now()
+        WHERE id = $1
+        RETURNING *
+        `, [
+        input.traceId,
+        input.statusCode,
+        input.durationMs,
+        input.metadata === undefined ? undefined : JSON.stringify(input.metadata),
+    ]);
+    return result.rows[0];
+}
+export async function createTraceSpan(pool, input) {
+    const result = await pool.query(`
+        INSERT INTO flowwatch_trace_spans (
+            id,
+            trace_id,
+            parent_span_id,
+            name,
+            type,
+            status,
+            metadata,
+            started_at
+        )
+        VALUES ($1, $2, $3, $4, $5, 'running', $6::jsonb, now())
+        RETURNING *
+        `, [
+        randomUUID(),
+        input.traceId,
+        input.parentSpanId ?? null,
+        input.name,
+        input.type,
+        JSON.stringify(input.metadata ?? {}),
+    ]);
+    return result.rows[0];
+}
+export async function finishTraceSpan(pool, input) {
+    const result = await pool.query(`
+        UPDATE flowwatch_trace_spans
+        SET status = $2,
+            duration_ms = $3,
+            metadata = COALESCE($4::jsonb, metadata),
+            ended_at = now()
+        WHERE id = $1
+        RETURNING *
+        `, [
+        input.spanId,
+        input.status,
+        input.durationMs,
+        input.metadata === undefined ? undefined : JSON.stringify(input.metadata),
+    ]);
+    return result.rows[0];
+}
+export async function getRequestTrace(pool, traceId) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_request_traces
+        WHERE id = $1
+        `, [traceId]);
+    return result.rows[0];
+}
+export async function listRequestTraces(pool, limit = 50) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_request_traces
+        ORDER BY started_at DESC
+        LIMIT $1
+        `, [limit]);
+    return result.rows;
+}
+export async function getTraceSpans(pool, traceId) {
+    const result = await pool.query(`
+        SELECT *
+        FROM flowwatch_trace_spans
+        WHERE trace_id = $1
+        ORDER BY started_at ASC
+        `, [traceId]);
+    return result.rows;
+}

package/dist/persistence/repositories/workflows/workflowRepository.d.ts

@@ -0,0 +1,93 @@
+import type { Pool } from "pg";
+export interface WorkflowStepDefinitionInput {
+    name: string;
+    maxRetries?: number;
+}
+export interface CreateWorkflowDefinitionInput {
+    name: string;
+    version?: number;
+    steps: WorkflowStepDefinitionInput[];
+}
+export interface WorkflowDefinitionRecord {
+    id: string;
+    name: string;
+    version: number;
+    created_at?: Date;
+    updated_at?: Date;
+}
+export interface WorkflowStepRecord {
+    id: string;
+    workflowId: string;
+    stepIndex: number;
+    name: string;
+    maxRetries: number;
+}
+export interface InsertWorkflowResult {
+    workflow: WorkflowDefinitionRecord;
+    steps: WorkflowStepRecord[];
+}
+export interface WorkflowExecutionInput {
+    workflowId: string;
+    workflowName: string;
+    workflowVersion: number;
+    input?: unknown;
+    steps: WorkflowExecutionStepInput[];
+}
+export interface WorkflowExecutionStepInput {
+    workflowStepId: string;
+    stepIndex: number;
+    stepName: string;
+    maxRetries: number;
+    input?: unknown;
+}
+export interface WorkflowExecutionRecord {
+    executionId: string;
+}
+export interface WorkflowExecutionRow {
+    id: string;
+    workflow_id: string;
+    workflow_name: string;
+    workflow_version: number;
+    status: string;
+    input: unknown;
+    output: unknown;
+    error: unknown;
+    created_at: Date;
+    started_at: Date | null;
+    completed_at: Date | null;
+    failed_at: Date | null;
+}
+export interface WorkflowStepExecutionRow {
+    id: string;
+    execution_id: string;
+    workflow_step_id: string | null;
+    step_index: number;
+    step_name: string;
+    status: string;
+    input: unknown;
+    output: unknown;
+    error: unknown;
+    attempt_count: number;
+    max_retries: number;
+    created_at: Date;
+    started_at: Date | null;
+    completed_at: Date | null;
+    failed_at: Date | null;
+    next_retry_at: Date | null;
+}
+export declare function insertWorkflow(pool: Pool, input: CreateWorkflowDefinitionInput): Promise<InsertWorkflowResult>;
+export declare function insertWorkflowExecution(pool: Pool, input: WorkflowExecutionInput): Promise<WorkflowExecutionRecord>;
+export declare function getWorkflowExecution(pool: Pool, executionId: string): Promise<WorkflowExecutionRow | undefined>;
+export declare function listWorkflowDefinitions(pool: Pool): Promise<WorkflowDefinitionRecord[]>;
+export declare function getLatestWorkflowDefinitionByName(pool: Pool, workflowName: string): Promise<WorkflowDefinitionRecord | undefined>;
+export declare function listWorkflowExecutions(pool: Pool, limit?: number): Promise<WorkflowExecutionRow[]>;
+export declare function listWorkflowExecutionsByWorkflowName(pool: Pool, workflowName: string, limit?: number): Promise<WorkflowExecutionRow[]>;
+export declare function listWorkflowStepExecutionsByExecutionIds(pool: Pool, executionIds: string[]): Promise<Map<string, WorkflowStepExecutionRow[]>>;
+export declare function listWorkflowStepsByWorkflowIds(pool: Pool, workflowIds: string[]): Promise<Map<string, WorkflowStepRecord[]>>;
+export declare function getWorkflowExecutionSteps(pool: Pool, executionId: string): Promise<WorkflowStepExecutionRow[]>;
+export declare function markWorkflowExecutionRunning(pool: Pool, executionId: string): Promise<void>;
+export declare function markWorkflowExecutionCompleted(pool: Pool, executionId: string, output?: unknown): Promise<void>;
+export declare function markWorkflowExecutionFailed(pool: Pool, executionId: string, error: unknown): Promise<void>;
+export declare function markWorkflowStepRunning(pool: Pool, stepExecutionId: string): Promise<void>;
+export declare function markWorkflowStepCompleted(pool: Pool, stepExecutionId: string, output?: unknown): Promise<void>;
+export declare function markWorkflowStepFailed(pool: Pool, stepExecutionId: string, error: unknown): Promise<void>;