@flipboxlabs/aws-audit-sdk 1.1.0

package/dist/service.d.ts

@@ -0,0 +1,285 @@
+import type { Logger } from "@aws-lambda-powertools/logger";
+import type { AuditConfig } from "./config.js";
+import { AuditEventBus } from "./events/bus.js";
+import { AuditRepository } from "./repository.js";
+import type { Audit } from "./schema/audit.js";
+import type { Pagination } from "./schema/model.js";
+import { type UpsertAuditInput } from "./schema/service.js";
+import type { InferApp, InferResourceType } from "./types.js";
+/**
+ * Typed identifiers for locating audit records.
+ * Uses config-derived App and ResourceType types for strict typing.
+ */
+export type TypedIdentifiers<C extends AuditConfig> = {
+    /** Tenant/organization identifier for multi-tenancy support (optional) */
+    tenantId?: string;
+    /** Unique audit record identifier */
+    id: string | number;
+    /** Application that owns this audit record */
+    app: InferApp<C>;
+    /** Optional resource identifier within the application */
+    resourceId?: string | number;
+    /** Type of resource being audited */
+    resourceType: InferResourceType<C>;
+};
+/**
+ * Typed options for listing audit items by resource.
+ * Uses config-derived App and ResourceType types for strict typing.
+ */
+export type TypedListItemsOptions<C extends AuditConfig> = {
+    /** Tenant/organization identifier for multi-tenancy support (optional) */
+    tenantId?: string;
+    /** Resource identification */
+    resource: {
+        /** Type of the resource */
+        type: InferResourceType<C>;
+        /** Unique identifier of the resource */
+        id: string;
+    };
+    /** Application owning the resource */
+    app: InferApp<C>;
+};
+/**
+ * Typed options for listing audit items by trace ID.
+ * Uses config-derived App and ResourceType types for strict typing.
+ */
+export type TypedListTraceItems<C extends AuditConfig> = {
+    /** Tenant/organization identifier for multi-tenancy support (optional) */
+    tenantId?: string;
+    /** Trace ID to query for related audit records */
+    trace: string;
+    /** Optional application filter */
+    app?: InferApp<C>;
+    /** Optional resource filter */
+    resource?: {
+        /** Filter by resource type */
+        type?: InferResourceType<C>;
+        /** Filter by resource ID */
+        id?: string;
+    };
+};
+/**
+ * High-level service for managing audit records with typed App and ResourceType.
+ *
+ * Provides a business logic layer over the AuditRepository for CRUD operations
+ * and coordinates with EventBridge for event-driven notifications.
+ *
+ * Features:
+ * - Type-safe app and resourceType parameters derived from config
+ * - Automatic creation of related resource audit entries
+ * - Schema validation on upsert operations
+ * - EventBridge integration for audit event notifications
+ * - Paginated list queries with filtering
+ *
+ * @typeParam C - The audit config type for type inference
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * const service = new AuditService(logger, config);
+ *
+ * // Upsert an audit with related resources
+ * await service.upsertItem({
+ *   operation: 'createOrder',
+ *   target: { app: 'Orders', type: 'Order', id: '123' },
+ *   resources: [
+ *     { app: 'Inventory', type: 'Product', id: '456' },
+ *   ],
+ * });
+ *
+ * // Retrieve a specific audit - app and resourceType are typed!
+ * const audit = await service.getItem({
+ *   id: 'audit-123',
+ *   app: 'Orders',        // TypeScript knows valid values
+ *   resourceType: 'Order', // Autocomplete works
+ * });
+ * ```
+ */
+export declare class AuditService<C extends AuditConfig> {
+    private readonly logger;
+    readonly events: null | undefined | AuditEventBus;
+    private readonly storage;
+    private readonly config;
+    /**
+     * Creates a new AuditService instance.
+     *
+     * @param logger - Logger instance for error logging
+     * @param config - Audit configuration for type inference
+     * @param storage - Repository for DynamoDB operations (defaults to new AuditRepository)
+     * @param events - EventBridge bus for audit notifications (defaults to new AuditEventBus, can be null/undefined to disable)
+     */
+    constructor(logger: Logger, config: C, storage?: AuditRepository<C>, events?: null | undefined | AuditEventBus);
+    /**
+     * Retrieves a single audit record by its identifiers.
+     *
+     * @param identifiers - The audit identifiers (id, app, resourceType)
+     * @returns The audit record
+     * @throws Error if the audit record is not found
+     *
+     * @example
+     * ```typescript
+     * const audit = await service.getItem({
+     *   id: 'audit-123',
+     *   app: 'MyApp',
+     *   resourceType: 'User',
+     * });
+     * ```
+     */
+    getItem(identifiers: Omit<TypedIdentifiers<C>, "resourceId">): Promise<Audit>;
+    /**
+     * Creates or updates an audit record and its related resource entries.
+     *
+     * For each resource in the `resources` array that has an ID:
+     * - Creates a separate audit entry with the resource as the target
+     * - Links it to the parent audit via a generated composite ID
+     * - Sets the original target as the source
+     * - Inherits rerunable status from the parent or event presence
+     *
+     * When an audit with the same ID already exists (retry scenario):
+     * - Appends the current execution to the `attempts` array
+     * - Preserves the original `createdAt` timestamp
+     * - Increments the attempt number automatically
+     *
+     * After storage, publishes an "Upserted" event to EventBridge (if events is configured).
+     *
+     * @param input - The audit data to upsert
+     *
+     * @example
+     * ```typescript
+     * await service.upsertItem({
+     *   operation: 'processPayment',
+     *   target: { app: 'Payments', type: 'Transaction', id: 'txn-123' },
+     *   status: 'success',
+     *   resources: [
+     *     { app: 'Users', type: 'User', id: 'user-456' },
+     *     { app: 'Orders', type: 'Order', id: 'order-789' },
+     *   ],
+     * });
+     * ```
+     */
+    upsertItem(input: UpsertAuditInput): Promise<void>;
+    /**
+     * Lists audit records with filtering and pagination.
+     *
+     * Queries audits based on resource type, app, and optional resource ID.
+     * Results are paginated and can be filtered by various criteria.
+     *
+     * @param params - Query parameters for filtering
+     * @param pagination - Optional pagination settings
+     * @returns Paginated collection of audit records
+     * @throws Re-throws any storage errors after logging
+     *
+     * @example
+     * ```typescript
+     * const { items, pagination } = await service.listItems({
+     *   resource: { type: 'Order', id: '123' },
+     *   app: 'Orders',
+     * });
+     * ```
+     */
+    listItems(params: TypedListItemsOptions<C>, pagination?: Pagination): Promise<{
+        items: {
+            id: string;
+            status: "success" | "warn" | "fail" | "skip";
+            tier: number;
+            target: {
+                app: string;
+                type: string;
+                id?: string | number | undefined;
+            };
+            operation: string;
+            tenantId?: string | undefined;
+            source?: {
+                app: string;
+                type: string;
+                id?: string | number | undefined;
+            } | undefined;
+            context?: Record<string, string | number | boolean | {
+                [key: string]: string | number | boolean | /*elided*/ any;
+            }> | undefined;
+            message?: string | undefined;
+            rerunable?: boolean | undefined;
+            trace?: string | undefined;
+            event?: {
+                detail: string | undefined;
+                source?: string | undefined;
+                "detail-type"?: string | undefined;
+            } | undefined;
+            error?: any;
+            attempts?: {
+                number: number;
+                status: "success" | "warn" | "fail" | "skip";
+                at: string;
+                error?: any;
+            }[] | undefined;
+        }[];
+        pagination?: {
+            pageSize?: string | number | null | undefined;
+            nextToken?: string | null | undefined;
+        } | undefined;
+    }>;
+    /**
+     * Lists audit records by trace ID with pagination.
+     *
+     * Retrieves all audits associated with a distributed trace,
+     * ordered by their stage in the processing pipeline.
+     *
+     * @param params - Query parameters including the trace ID
+     * @param pagination - Optional pagination settings
+     * @returns Paginated collection of trace-related audit records
+     * @throws Re-throws any storage errors after logging
+     *
+     * @example
+     * ```typescript
+     * const { items } = await service.listTraceItems({
+     *   trace: 'trace-abc-123',
+     * });
+     * ```
+     */
+    listTraceItems(params: TypedListTraceItems<C>, pagination?: Pagination): Promise<{
+        items: {
+            id: string;
+            status: "success" | "warn" | "fail" | "skip";
+            tier: number;
+            target: {
+                app: string;
+                type: string;
+                id?: string | number | undefined;
+            };
+            operation: string;
+            tenantId?: string | undefined;
+            source?: {
+                app: string;
+                type: string;
+                id?: string | number | undefined;
+            } | undefined;
+            context?: Record<string, string | number | boolean | {
+                [key: string]: string | number | boolean | /*elided*/ any;
+            }> | undefined;
+            message?: string | undefined;
+            rerunable?: boolean | undefined;
+            trace?: string | undefined;
+            event?: {
+                detail: string | undefined;
+                source?: string | undefined;
+                "detail-type"?: string | undefined;
+            } | undefined;
+            error?: any;
+            attempts?: {
+                number: number;
+                status: "success" | "warn" | "fail" | "skip";
+                at: string;
+                error?: any;
+            }[] | undefined;
+        }[];
+        pagination?: {
+            pageSize?: string | number | null | undefined;
+            nextToken?: string | null | undefined;
+        } | undefined;
+    }>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/dist/service.js

@@ -0,0 +1,237 @@
+import { AuditEventBus } from "./events/bus.js";
+import { AuditRepository } from "./repository.js";
+import { createTypedUpsertAuditSchema, } from "./schema/service.js";
+/**
+ * High-level service for managing audit records with typed App and ResourceType.
+ *
+ * Provides a business logic layer over the AuditRepository for CRUD operations
+ * and coordinates with EventBridge for event-driven notifications.
+ *
+ * Features:
+ * - Type-safe app and resourceType parameters derived from config
+ * - Automatic creation of related resource audit entries
+ * - Schema validation on upsert operations
+ * - EventBridge integration for audit event notifications
+ * - Paginated list queries with filtering
+ *
+ * @typeParam C - The audit config type for type inference
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * const service = new AuditService(logger, config);
+ *
+ * // Upsert an audit with related resources
+ * await service.upsertItem({
+ *   operation: 'createOrder',
+ *   target: { app: 'Orders', type: 'Order', id: '123' },
+ *   resources: [
+ *     { app: 'Inventory', type: 'Product', id: '456' },
+ *   ],
+ * });
+ *
+ * // Retrieve a specific audit - app and resourceType are typed!
+ * const audit = await service.getItem({
+ *   id: 'audit-123',
+ *   app: 'Orders',        // TypeScript knows valid values
+ *   resourceType: 'Order', // Autocomplete works
+ * });
+ * ```
+ */
+export class AuditService {
+    logger;
+    events;
+    storage;
+    config;
+    /**
+     * Creates a new AuditService instance.
+     *
+     * @param logger - Logger instance for error logging
+     * @param config - Audit configuration for type inference
+     * @param storage - Repository for DynamoDB operations (defaults to new AuditRepository)
+     * @param events - EventBridge bus for audit notifications (defaults to new AuditEventBus, can be null/undefined to disable)
+     */
+    constructor(logger, config, storage, events = new AuditEventBus(logger)) {
+        this.logger = logger;
+        this.events = events;
+        this.config = config;
+        this.storage = storage ?? new AuditRepository(logger, config);
+    }
+    /**
+     * Retrieves a single audit record by its identifiers.
+     *
+     * @param identifiers - The audit identifiers (id, app, resourceType)
+     * @returns The audit record
+     * @throws Error if the audit record is not found
+     *
+     * @example
+     * ```typescript
+     * const audit = await service.getItem({
+     *   id: 'audit-123',
+     *   app: 'MyApp',
+     *   resourceType: 'User',
+     * });
+     * ```
+     */
+    async getItem(identifiers) {
+        const result = await this.storage.getItem(identifiers);
+        if (result == null) {
+            throw new Error(`Unable to find Audit ${Array.from(Object.entries(identifiers))
+                .map(([key, value]) => `${key}:${value}`)
+                .join(" | ")}`);
+        }
+        return result;
+    }
+    /**
+     * Creates or updates an audit record and its related resource entries.
+     *
+     * For each resource in the `resources` array that has an ID:
+     * - Creates a separate audit entry with the resource as the target
+     * - Links it to the parent audit via a generated composite ID
+     * - Sets the original target as the source
+     * - Inherits rerunable status from the parent or event presence
+     *
+     * When an audit with the same ID already exists (retry scenario):
+     * - Appends the current execution to the `attempts` array
+     * - Preserves the original `createdAt` timestamp
+     * - Increments the attempt number automatically
+     *
+     * After storage, publishes an "Upserted" event to EventBridge (if events is configured).
+     *
+     * @param input - The audit data to upsert
+     *
+     * @example
+     * ```typescript
+     * await service.upsertItem({
+     *   operation: 'processPayment',
+     *   target: { app: 'Payments', type: 'Transaction', id: 'txn-123' },
+     *   status: 'success',
+     *   resources: [
+     *     { app: 'Users', type: 'User', id: 'user-456' },
+     *     { app: 'Orders', type: 'Order', id: 'order-789' },
+     *   ],
+     * });
+     * ```
+     */
+    async upsertItem(input) {
+        const schema = createTypedUpsertAuditSchema(this.config.schemas.resourceReference);
+        const item = schema.parse(input);
+        const now = new Date().toISOString();
+        // Build current attempt record
+        const currentAttempt = {
+            number: 1,
+            status: item.status,
+            error: item.error,
+            at: now,
+        };
+        // Check for existing audit to handle retry tracking
+        if (item.id) {
+            try {
+                const existing = await this.storage.getItem({
+                    id: item.id,
+                    app: item.target.app,
+                    resourceType: item.target.type,
+                    tenantId: item.tenantId,
+                });
+                if (existing) {
+                    // Append to existing attempts array
+                    const existingAttempts = existing.attempts ?? [];
+                    currentAttempt.number = existingAttempts.length + 1;
+                    item.attempts = [...existingAttempts, currentAttempt];
+                    // Preserve original createdAt
+                    item.createdAt = existing.createdAt.toISOString();
+                }
+                else {
+                    item.attempts = [currentAttempt];
+                }
+            }
+            catch {
+                // Audit doesn't exist, this is the first attempt
+                item.attempts = [currentAttempt];
+            }
+        }
+        else {
+            item.attempts = [currentAttempt];
+        }
+        const batch = Array.from(item.resources || [])
+            .filter((resource) => !!resource.id)
+            .map((resource) => ({
+            ...item,
+            ...resource,
+            id: `${item.id}#${resource.app}.${resource.type}#${resource.id}`, // deterministic ID for retry correlation
+            // Source
+            source: item.target,
+            rerunable: item.rerunable !== undefined ? item.rerunable : !!item.event,
+            // Remove these (they are only needed on the parent)
+            event: undefined,
+            result: undefined,
+            error: undefined,
+            attempts: undefined,
+        }));
+        await this.storage.upsertBatch([item, ...batch]);
+        await this.events?.upserted([item]);
+    }
+    /**
+     * Lists audit records with filtering and pagination.
+     *
+     * Queries audits based on resource type, app, and optional resource ID.
+     * Results are paginated and can be filtered by various criteria.
+     *
+     * @param params - Query parameters for filtering
+     * @param pagination - Optional pagination settings
+     * @returns Paginated collection of audit records
+     * @throws Re-throws any storage errors after logging
+     *
+     * @example
+     * ```typescript
+     * const { items, pagination } = await service.listItems({
+     *   resource: { type: 'Order', id: '123' },
+     *   app: 'Orders',
+     * });
+     * ```
+     */
+    async listItems(params, pagination) {
+        try {
+            return await this.storage.listItems(params, pagination);
+        }
+        catch (error) {
+            this.logger.error("An error occurred while trying to list items", {
+                error,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Lists audit records by trace ID with pagination.
+     *
+     * Retrieves all audits associated with a distributed trace,
+     * ordered by their stage in the processing pipeline.
+     *
+     * @param params - Query parameters including the trace ID
+     * @param pagination - Optional pagination settings
+     * @returns Paginated collection of trace-related audit records
+     * @throws Re-throws any storage errors after logging
+     *
+     * @example
+     * ```typescript
+     * const { items } = await service.listTraceItems({
+     *   trace: 'trace-abc-123',
+     * });
+     * ```
+     */
+    async listTraceItems(params, pagination) {
+        try {
+            return await this.storage.listTraceItems(params, pagination);
+        }
+        catch (error) {
+            this.logger.error("An error occurred while trying to list trace items", {
+                error,
+            });
+            throw error;
+        }
+    }
+}

package/dist/test-config.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Test configuration for SDK tests.
+ * Provides sample apps and resource types for testing.
+ */
+export declare const testConfig: {
+    service: string | undefined;
+} & {
+    readonly apps: readonly ["App1", "TestApp"];
+    readonly resourceTypes: readonly ["Unknown", "User", "Order"];
+} & {
+    schemas: {
+        app: import("zod").ZodEnum<{
+            [x: string]: string;
+        }>;
+        resourceType: import("zod").ZodEnum<{
+            [x: string]: string;
+        }>;
+        resourceReference: import("zod").ZodObject<{
+            app: import("zod").ZodEnum<{
+                [x: string]: string;
+            }>;
+            type: import("zod").ZodEnum<{
+                [x: string]: string;
+            }>;
+            id: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    _types: {
+        App: "App1" | "TestApp";
+        ResourceType: "Unknown" | "User" | "Order";
+    };
+};
+/**
+ * Type alias for the App union type from the test config.
+ */
+export type App = (typeof testConfig)["_types"]["App"];
+/**
+ * Type alias for the ResourceType union type from the test config.
+ */
+export type ResourceType = (typeof testConfig)["_types"]["ResourceType"];
+/**
+ * Enum-like object for App values in tests.
+ */
+export declare const App: {
+    readonly App1: "App1";
+    readonly TestApp: "TestApp";
+};
+/**
+ * Enum-like object for ResourceType values in tests.
+ */
+export declare const ResourceType: {
+    readonly UNKNOWN: "Unknown";
+    readonly USER: "User";
+    readonly ORDER: "Order";
+};
+//# sourceMappingURL=test-config.d.ts.map

package/dist/test-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-config.d.ts","sourceRoot":"","sources":["../src/test-config.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGrB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,GAAG;;;CAGN,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;;;;CAIf,CAAC"}

package/dist/test-config.js

@@ -0,0 +1,24 @@
+import { defineAuditConfig } from "./config.js";
+/**
+ * Test configuration for SDK tests.
+ * Provides sample apps and resource types for testing.
+ */
+export const testConfig = defineAuditConfig({
+    apps: ["App1", "TestApp"],
+    resourceTypes: ["Unknown", "User", "Order"],
+});
+/**
+ * Enum-like object for App values in tests.
+ */
+export const App = {
+    App1: "App1",
+    TestApp: "TestApp",
+};
+/**
+ * Enum-like object for ResourceType values in tests.
+ */
+export const ResourceType = {
+    UNKNOWN: "Unknown",
+    USER: "User",
+    ORDER: "Order",
+};

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import type { AuditConfig } from "./config.js";
+/**
+ * Extracts the App type from an AuditConfig.
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * type App = InferApp<typeof config>; // 'Orders' | 'Inventory'
+ * ```
+ */
+export type InferApp<C extends AuditConfig> = C["_types"]["App"];
+/**
+ * Extracts the ResourceType type from an AuditConfig.
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * type ResourceType = InferResourceType<typeof config>; // 'Order' | 'Product'
+ * ```
+ */
+export type InferResourceType<C extends AuditConfig> = C["_types"]["ResourceType"];
+/**
+ * Generic App type - accepts any string.
+ * For strict typing, use InferApp<typeof config> with your config.
+ */
+export type AnyApp = string;
+/**
+ * Generic ResourceType type - accepts any string.
+ * For strict typing, use InferResourceType<typeof config> with your config.
+ */
+export type AnyResourceType = string;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,WAAW,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,WAAW,IAClD,CAAC,CAAC,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC;AAE7B;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};