@pipeline-builder/pipeline-data 3.1.0

package/lib/api/crud-service.d.ts

@@ -0,0 +1,170 @@
+import { SQL } from 'drizzle-orm';
+import type { AnyColumn } from 'drizzle-orm/column';
+import type { PgTable } from 'drizzle-orm/pg-core';
+/**
+ * Cast Drizzle query results to a typed array.
+ * Drizzle's generic return type (`PgSelectBase<...>`) doesn't narrow to our
+ * entity generics, so an explicit cast is needed. Centralised here so every
+ * call-site stays one-liner clean and the cast is documented in one place.
+ */
+export declare function drizzleRows<T>(rows: unknown): T[];
+/** Cast a Drizzle aggregate result to extract `[{ count: number }]`. */
+export declare function drizzleCount(rows: unknown): [{
+    count: number;
+}];
+/**
+ * Base interface for entities with common fields
+ */
+export interface BaseEntity {
+    id: string;
+    orgId: string;
+    isDefault: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+    updatedBy: string;
+    [key: string]: unknown;
+}
+/**
+ * Pagination and sorting options
+ */
+export interface QueryOptions {
+    limit?: number;
+    offset?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    /** When true, runs a separate COUNT(*) query to include exact total. Default: false. */
+    includeTotal?: boolean;
+    /** Cursor-based pagination: fetch rows after this cursor value (uses sortBy column). */
+    cursor?: string;
+    /** Sparse fieldset: column names to select. Returns all columns when omitted. */
+    fields?: string[];
+}
+/**
+ * Paginated result with metadata
+ */
+export interface PaginatedResult<T> {
+    data: T[];
+    /** Total count of matching entities. Only present when includeTotal is true. */
+    total?: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+    /** Cursor pointing to the last item, for cursor-based pagination. */
+    nextCursor?: string;
+}
+/**
+ * Abstract CRUD service with access control and common operations.
+ *
+ * @typeParam TEntity - Entity type extending BaseEntity
+ * @typeParam TFilter - Filter type for query parameters
+ * @typeParam TInsert - Insert DTO type
+ * @typeParam TUpdate - Update DTO type
+ *
+ * Type assertions (`as any`, `as unknown as T`) are used throughout for Drizzle ORM compatibility.
+ * This is safe because: access control filters by orgId, schema validation is at the DB level,
+ * and each subclass is tested for type correctness.
+ *
+ * Errors are not caught here — they propagate to the route-level error handler (`withRoute`)
+ * which provides consistent logging with request context.
+ *
+ * @example
+ * ```typescript
+ * class PipelineService extends CrudService<Pipeline, PipelineFilter, PipelineInsert, PipelineUpdate> {
+ *   protected get schema() { return schema.pipeline; }
+ *   protected buildConditions(filter, orgId) { return buildPipelineConditions(filter, orgId); }
+ *   protected getSortColumn(sortBy) { return sortColumnMap[sortBy] ?? null; }
+ *   protected getProjectColumn() { return schema.pipeline.project; }
+ *   protected getOrgColumn() { return schema.pipeline.organization; }
+ * }
+ * ```
+ */
+export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, TInsert, TUpdate> {
+    /** Drizzle schema table for this entity */
+    protected abstract get schema(): PgTable;
+    /** Build SQL conditions for filtering entities */
+    protected abstract buildConditions(filter: Partial<TFilter>, orgId?: string): SQL[];
+    /** Get the schema column for sorting by field name */
+    protected abstract getSortColumn(sortBy: string): AnyColumn | null;
+    /** Get the project column for setDefault scoping (null if entity has no project scope) */
+    protected abstract getProjectColumn(): AnyColumn | null;
+    /** Get the organization column for setDefault scoping */
+    protected abstract getOrgColumn(): AnyColumn;
+    /** Get the unique constraint columns for onConflictDoUpdate */
+    protected abstract get conflictTarget(): AnyColumn[];
+    private readonly _logger;
+    /** Build conditions for a single entity by ID. */
+    private idConditions;
+    /** Called after a new entity is created */
+    protected onAfterCreate(_entity: TEntity, _userId: string): Promise<void>;
+    /** Called after an entity is updated */
+    protected onAfterUpdate(_id: string, _entity: TEntity, _userId: string): Promise<void>;
+    /** Called after an entity is soft-deleted */
+    protected onAfterDelete(_id: string, _entity: TEntity, _userId: string): Promise<void>;
+    /**
+     * Find entities matching filter criteria
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    find(filter: Partial<TFilter>, orgId?: string): Promise<TEntity[]>;
+    /**
+     * Find entities with pagination and sorting
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     * @param options - Pagination and sorting options
+     */
+    findPaginated(filter: Partial<TFilter>, orgId?: string, options?: QueryOptions): Promise<PaginatedResult<TEntity>>;
+    /**
+     * Build a column selection map for sparse fieldsets.
+     * Falls back to full select if no matching columns found.
+     */
+    private buildFieldSelect;
+    /**
+     * Count entities matching filter criteria
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    count(filter: Partial<TFilter>, orgId?: string): Promise<number>;
+    /**
+     * Find a single entity by ID
+     *
+     * @param id - Entity ID
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    findById(id: string, orgId?: string): Promise<TEntity | null>;
+    /**
+     * Create a new entity
+     */
+    create(data: TInsert, userId: string): Promise<TEntity>;
+    /**
+     * Update an existing entity
+     */
+    update(id: string, data: Partial<TUpdate>, orgId: string, userId: string): Promise<TEntity | null>;
+    /**
+     * Delete an entity (soft delete by setting isActive = false)
+     */
+    delete(id: string, orgId: string, userId: string): Promise<TEntity | null>;
+    /**
+     * Set an entity as the default for a project/organization scope.
+     * Marks all other entities as non-default, then sets the specified entity.
+     * Uses a transaction to ensure atomicity.
+     */
+    setDefault(project: string, org: string, id: string, userId: string): Promise<TEntity>;
+    /**
+     * Update multiple entities matching filter
+     */
+    updateMany(filter: Partial<TFilter>, data: Partial<TUpdate>, orgId: string, userId: string): Promise<TEntity[]>;
+    /**
+     * Create multiple entities in a single batch insert.
+     * Uses upsert (onConflictDoUpdate) — all rows are inserted in one query per chunk.
+     * Chunks of 100 to stay within PostgreSQL parameter limits.
+     */
+    bulkCreate(items: TInsert[], userId: string): Promise<TEntity[]>;
+    /**
+     * Soft-delete multiple entities by IDs in a single batch operation.
+     */
+    bulkDelete(ids: string[], orgId: string, userId: string): Promise<TEntity[]>;
+}

package/lib/api/crud-service.js

@@ -0,0 +1,387 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudService = void 0;
+exports.drizzleRows = drizzleRows;
+exports.drizzleCount = drizzleCount;
+const api_core_1 = require("@pipeline-builder/api-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const postgres_connection_1 = require("../database/postgres-connection");
+/** Pagination defaults — read from env to match CoreConstants in pipeline-core. */
+const DEFAULT_PAGE_LIMIT = parseInt(process.env.DEFAULT_PAGE_LIMIT || '100', 10);
+const MAX_PAGE_LIMIT = parseInt(process.env.MAX_PAGE_LIMIT || '1000', 10);
+/**
+ * Cast Drizzle query results to a typed array.
+ * Drizzle's generic return type (`PgSelectBase<...>`) doesn't narrow to our
+ * entity generics, so an explicit cast is needed. Centralised here so every
+ * call-site stays one-liner clean and the cast is documented in one place.
+ */
+function drizzleRows(rows) {
+    return rows;
+}
+/** Cast a Drizzle aggregate result to extract `[{ count: number }]`. */
+function drizzleCount(rows) {
+    return rows;
+}
+/**
+ * Abstract CRUD service with access control and common operations.
+ *
+ * @typeParam TEntity - Entity type extending BaseEntity
+ * @typeParam TFilter - Filter type for query parameters
+ * @typeParam TInsert - Insert DTO type
+ * @typeParam TUpdate - Update DTO type
+ *
+ * Type assertions (`as any`, `as unknown as T`) are used throughout for Drizzle ORM compatibility.
+ * This is safe because: access control filters by orgId, schema validation is at the DB level,
+ * and each subclass is tested for type correctness.
+ *
+ * Errors are not caught here — they propagate to the route-level error handler (`withRoute`)
+ * which provides consistent logging with request context.
+ *
+ * @example
+ * ```typescript
+ * class PipelineService extends CrudService<Pipeline, PipelineFilter, PipelineInsert, PipelineUpdate> {
+ *   protected get schema() { return schema.pipeline; }
+ *   protected buildConditions(filter, orgId) { return buildPipelineConditions(filter, orgId); }
+ *   protected getSortColumn(sortBy) { return sortColumnMap[sortBy] ?? null; }
+ *   protected getProjectColumn() { return schema.pipeline.project; }
+ *   protected getOrgColumn() { return schema.pipeline.organization; }
+ * }
+ * ```
+ */
+class CrudService {
+    _logger = (0, api_core_1.createLogger)('CrudService');
+    /** Build conditions for a single entity by ID. */
+    idConditions(id, orgId) {
+        return this.buildConditions({ id }, orgId);
+    }
+    // Lifecycle hooks — override in subclasses to react to mutations
+    // These are fire-and-forget: errors are logged but never block the caller.
+    /** Called after a new entity is created */
+    async onAfterCreate(_entity, _userId) { }
+    /** Called after an entity is updated */
+    async onAfterUpdate(_id, _entity, _userId) { }
+    /** Called after an entity is soft-deleted */
+    async onAfterDelete(_id, _entity, _userId) { }
+    /**
+     * Find entities matching filter criteria
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    async find(filter, orgId) {
+        const conditions = this.buildConditions(filter, orgId);
+        return postgres_connection_1.db
+            .select()
+            .from(this.schema)
+            .where((0, drizzle_orm_1.and)(...conditions)).then(r => drizzleRows(r));
+    }
+    /**
+     * Find entities with pagination and sorting
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     * @param options - Pagination and sorting options
+     */
+    async findPaginated(filter, orgId, options = {}) {
+        const { limit: rawLimit = DEFAULT_PAGE_LIMIT, offset = 0, sortBy, sortOrder = 'asc', includeTotal = false, cursor, fields } = options;
+        const limit = Math.min(Math.max(1, rawLimit), MAX_PAGE_LIMIT);
+        // Cursor and offset are mutually exclusive — cursor takes precedence
+        const useCursor = !!(cursor && sortBy);
+        const conditions = this.buildConditions(filter, orgId);
+        // Cursor-based pagination: add WHERE clause for keyset pagination
+        if (useCursor) {
+            const sortColumn = this.getSortColumn(sortBy);
+            if (sortColumn) {
+                const op = sortOrder === 'desc'
+                    ? (0, drizzle_orm_1.sql) `${sortColumn} < ${cursor}`
+                    : (0, drizzle_orm_1.sql) `${sortColumn} > ${cursor}`;
+                conditions.push(op);
+            }
+        }
+        // Build SELECT — sparse fieldset when fields are specified
+        const selectSpec = fields ? this.buildFieldSelect(fields) : undefined;
+        let query = selectSpec
+            ? postgres_connection_1.db.select(selectSpec).from(this.schema).where((0, drizzle_orm_1.and)(...conditions))
+            : postgres_connection_1.db.select().from(this.schema).where((0, drizzle_orm_1.and)(...conditions));
+        if (sortBy) {
+            const sortColumn = this.getSortColumn(sortBy);
+            if (sortColumn) {
+                query = query.orderBy(sortOrder === 'desc' ? (0, drizzle_orm_1.desc)(sortColumn) : (0, drizzle_orm_1.asc)(sortColumn));
+            }
+        }
+        // Fetch limit+1 to detect hasMore without COUNT(*)
+        const effectiveOffset = useCursor ? 0 : offset;
+        const rows = await query
+            .limit(limit + 1)
+            .offset(effectiveOffset).then(r => drizzleRows(r));
+        const hasMore = rows.length > limit;
+        const data = hasMore ? rows.slice(0, limit) : rows;
+        const result = { data, limit, offset: effectiveOffset, hasMore };
+        // Provide next cursor from last item's sort column value
+        if (data.length > 0 && sortBy) {
+            const lastItem = data[data.length - 1];
+            const cursorValue = lastItem[sortBy];
+            if (cursorValue !== undefined) {
+                result.nextCursor = cursorValue instanceof Date ? cursorValue.toISOString() : String(cursorValue);
+            }
+        }
+        // Only run the COUNT(*) query when the caller explicitly needs the total
+        if (includeTotal) {
+            const baseConditions = this.buildConditions(filter, orgId);
+            const [countResult] = await postgres_connection_1.db
+                .select({ count: (0, drizzle_orm_1.sql) `count(*)::int` })
+                .from(this.schema)
+                .where((0, drizzle_orm_1.and)(...baseConditions)).then(r => drizzleCount(r));
+            result.total = countResult?.count || 0;
+        }
+        return result;
+    }
+    /**
+     * Build a column selection map for sparse fieldsets.
+     * Falls back to full select if no matching columns found.
+     */
+    buildFieldSelect(fields) {
+        if (fields.length === 0)
+            return undefined;
+        const columns = {};
+        // Always include id for entity identity
+        columns.id = this.schema.id;
+        for (const field of fields) {
+            if (field === 'id')
+                continue; // Already included
+            const col = this.schema[field];
+            if (col)
+                columns[field] = col;
+        }
+        // At minimum we'll have { id }, which is valid
+        return columns;
+    }
+    /**
+     * Count entities matching filter criteria
+     *
+     * @param filter - Filter criteria
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    async count(filter, orgId) {
+        const conditions = this.buildConditions(filter, orgId);
+        const [result] = await postgres_connection_1.db
+            .select({ count: (0, drizzle_orm_1.sql) `count(*)::int` })
+            .from(this.schema)
+            .where((0, drizzle_orm_1.and)(...conditions)).then(r => drizzleCount(r));
+        return result?.count || 0;
+    }
+    /**
+     * Find a single entity by ID
+     *
+     * @param id - Entity ID
+     * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
+     */
+    async findById(id, orgId) {
+        const conditions = this.idConditions(id, orgId);
+        const results = await postgres_connection_1.db
+            .select()
+            .from(this.schema)
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .limit(1).then(r => drizzleRows(r));
+        return results[0] || null;
+    }
+    // Mutation operations
+    /**
+     * Create a new entity
+     */
+    async create(data, userId) {
+        const [created] = await postgres_connection_1.db
+            .insert(this.schema)
+            .values({
+            ...data,
+            createdBy: userId || 'system',
+            updatedBy: userId || 'system',
+        })
+            .onConflictDoUpdate({
+            target: this.conflictTarget,
+            set: {
+                ...data,
+                updatedAt: new Date(),
+                updatedBy: userId || 'system',
+            },
+        })
+            .returning().then(r => drizzleRows(r));
+        this.onAfterCreate(created, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));
+        return created;
+    }
+    /**
+     * Update an existing entity
+     */
+    async update(id, data, orgId, userId) {
+        const conditions = this.idConditions(id, orgId);
+        const [updated] = await postgres_connection_1.db
+            .update(this.schema)
+            .set({
+            ...data,
+            updatedAt: new Date(),
+            updatedBy: userId || 'system',
+        })
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .returning().then(r => drizzleRows(r));
+        if (updated) {
+            this.onAfterUpdate(id, updated, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));
+        }
+        return updated || null;
+    }
+    /**
+     * Delete an entity (soft delete by setting isActive = false)
+     */
+    async delete(id, orgId, userId) {
+        const conditions = this.idConditions(id, orgId);
+        const [deleted] = await postgres_connection_1.db
+            .update(this.schema)
+            .set({
+            isActive: false,
+            updatedAt: new Date(),
+            updatedBy: userId || 'system',
+            deletedAt: new Date(),
+            deletedBy: userId || 'system',
+        })
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .returning().then(r => drizzleRows(r));
+        if (deleted) {
+            this.onAfterDelete(id, deleted, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));
+        }
+        return deleted || null;
+    }
+    /**
+     * Set an entity as the default for a project/organization scope.
+     * Marks all other entities as non-default, then sets the specified entity.
+     * Uses a transaction to ensure atomicity.
+     */
+    async setDefault(project, org, id, userId) {
+        return postgres_connection_1.db.transaction(async (tx) => {
+            const orgColumn = this.getOrgColumn();
+            const projectColumn = this.getProjectColumn();
+            // Build scoping conditions for clearing defaults
+            const scopeConditions = [
+                (0, drizzle_orm_1.eq)(orgColumn, org),
+                (0, drizzle_orm_1.eq)(this.schema.isDefault, true),
+            ];
+            if (projectColumn) {
+                scopeConditions.push((0, drizzle_orm_1.eq)(projectColumn, project));
+            }
+            // Lock existing defaults with FOR UPDATE to prevent concurrent setDefault races
+            await tx.execute((0, drizzle_orm_1.sql) `SELECT id FROM ${this.schema}
+            WHERE ${orgColumn} = ${org}
+              AND ${this.schema.isDefault} = true
+            ${projectColumn ? (0, drizzle_orm_1.sql) `AND ${projectColumn} = ${project}` : (0, drizzle_orm_1.sql) ``}
+            FOR UPDATE`);
+            // Mark all entities in scope as non-default
+            await tx
+                .update(this.schema)
+                .set({
+                isDefault: false,
+                updatedAt: new Date(),
+                updatedBy: userId || 'system',
+            })
+                .where((0, drizzle_orm_1.and)(...scopeConditions));
+            // Set the specified entity as default
+            const [updated] = await tx
+                .update(this.schema)
+                .set({
+                isDefault: true,
+                updatedAt: new Date(),
+                updatedBy: userId || 'system',
+            })
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.id, id), (0, drizzle_orm_1.eq)(orgColumn, org)))
+                .returning().then(r => drizzleRows(r));
+            if (!updated) {
+                throw new api_core_1.NotFoundError(`Entity with id ${id} not found`);
+            }
+            return updated;
+        });
+    }
+    /**
+     * Update multiple entities matching filter
+     */
+    async updateMany(filter, data, orgId, userId) {
+        const conditions = this.buildConditions(filter, orgId);
+        return postgres_connection_1.db
+            .update(this.schema)
+            .set({
+            ...data,
+            updatedAt: new Date(),
+            updatedBy: userId || 'system',
+        })
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .returning().then(r => drizzleRows(r));
+    }
+    /**
+     * Create multiple entities in a single batch insert.
+     * Uses upsert (onConflictDoUpdate) — all rows are inserted in one query per chunk.
+     * Chunks of 100 to stay within PostgreSQL parameter limits.
+     */
+    async bulkCreate(items, userId) {
+        if (items.length === 0)
+            return [];
+        const CHUNK_SIZE = 100;
+        const now = new Date();
+        const user = userId || 'system';
+        const results = await postgres_connection_1.db.transaction(async (tx) => {
+            const allCreated = [];
+            for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+                const chunk = items.slice(i, i + CHUNK_SIZE);
+                const values = chunk.map(data => ({
+                    ...data,
+                    createdBy: user,
+                    updatedBy: user,
+                }));
+                const created = await tx
+                    .insert(this.schema)
+                    .values(values)
+                    .onConflictDoUpdate({
+                    target: this.conflictTarget,
+                    set: {
+                        updatedAt: now,
+                        updatedBy: user,
+                    },
+                })
+                    .returning().then(r => drizzleRows(r));
+                allCreated.push(...created);
+            }
+            return allCreated;
+        });
+        for (const entity of results) {
+            this.onAfterCreate(entity, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));
+        }
+        return results;
+    }
+    /**
+     * Soft-delete multiple entities by IDs in a single batch operation.
+     */
+    async bulkDelete(ids, orgId, userId) {
+        if (ids.length === 0)
+            return [];
+        const now = new Date();
+        const user = userId || 'system';
+        const conditions = [
+            (0, drizzle_orm_1.inArray)(this.schema.id, ids),
+            ...this.buildConditions({}, orgId),
+        ];
+        const deleted = await postgres_connection_1.db
+            .update(this.schema)
+            .set({
+            isActive: false,
+            updatedAt: now,
+            updatedBy: user,
+            deletedAt: now,
+            deletedBy: user,
+        })
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .returning().then(r => drizzleRows(r));
+        for (const entity of deleted) {
+            this.onAfterDelete(entity.id, entity, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));
+        }
+        return deleted;
+    }
+}
+exports.CrudService = CrudService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud-service.js","sourceRoot":"","sources":["../../src/api/crud-service.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAkBtC,kCAEC;AAGD,oCAEC;AAvBD,yDAAyE;AACzE,6CAAoE;AAGpE,yEAAqD;AAErD,mFAAmF;AACnF,MAAM,kBAAkB,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,KAAK,EAAE,EAAE,CAAC,CAAC;AACjF,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,MAAM,EAAE,EAAE,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,SAAgB,WAAW,CAAI,IAAa;IAC1C,OAAO,IAAW,CAAC;AACrB,CAAC;AAED,wEAAwE;AACxE,SAAgB,YAAY,CAAC,IAAa;IACxC,OAAO,IAA2B,CAAC;AACrC,CAAC;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAsB,WAAW;IAwBd,OAAO,GAAG,IAAA,uBAAY,EAAC,aAAa,CAAC,CAAC;IAEvD,kDAAkD;IAC1C,YAAY,CAAC,EAAU,EAAE,KAAc;QAC7C,OAAO,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,EAAiC,EAAE,KAAK,CAAC,CAAC;IAC5E,CAAC;IAED,iEAAiE;IACjE,2EAA2E;IAE3E,2CAA2C;IACjC,KAAK,CAAC,aAAa,CAAC,OAAgB,EAAE,OAAe,IAAkB,CAAC;IAElF,wCAAwC;IAC9B,KAAK,CAAC,aAAa,CAAC,GAAW,EAAE,OAAgB,EAAE,OAAe,IAAkB,CAAC;IAE/F,6CAA6C;IACnC,KAAK,CAAC,aAAa,CAAC,GAAW,EAAE,OAAgB,EAAE,OAAe,IAAkB,CAAC;IAE/F;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,MAAwB,EAAE,KAAc;QACjD,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAEvD,OAAO,wBAAE;aACN,MAAM,EAAE;aACR,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;aACjB,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CACjB,MAAwB,EACxB,KAAc,EACd,UAAwB,EAAE;QAE1B,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,kBAAkB,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,GAAG,KAAK,EAAE,YAAY,GAAG,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QACtI,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC;QAE9D,qEAAqE;QACrE,MAAM,SAAS,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC;QAEvC,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAEvD,kEAAkE;QAClE,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,UAAU,EAAE,CAAC;gBACf,MAAM,EAAE,GAAG,SAAS,KAAK,MAAM;oBAC7B,CAAC,CAAC,IAAA,iBAAG,EAAA,GAAG,UAAU,MAAM,MAAM,EAAE;oBAChC,CAAC,CAAC,IAAA,iBAAG,EAAA,GAAG,UAAU,MAAM,MAAM,EAAE,CAAC;gBACnC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACtB,CAAC;QACH,CAAC;QAED,2DAA2D;QAC3D,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACtE,IAAI,KAAK,GAAG,UAAU;YACpB,CAAC,CAAC,wBAAE,CAAC,MAAM,CAAC,UAAiB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;YAC1E,CAAC,CAAC,wBAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QAE5D,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,UAAU,EAAE,CAAC;gBACf,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAA,kBAAI,EAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAA,iBAAG,EAAC,UAAU,CAAC,CAAQ,CAAC;YAC1F,CAAC;QACH,CAAC;QAED,mDAAmD;QACnD,MAAM,eAAe,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,KAAK;aACrB,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;aAChB,MAAM,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAE9D,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpC,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAEnD,MAAM,MAAM,GAA6B,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC;QAE3F,yDAAyD;QACzD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,EAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAA4B,CAAC;YAClE,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;YACrC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;gBAC9B,MAAM,CAAC,UAAU,GAAG,WAAW,YAAY,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YACpG,CAAC;QACH,CAAC;QAED,yEAAyE;QACzE,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YAC3D,MAAM,CAAC,WAAW,CAAC,GAAG,MAAM,wBAAE;iBAC3B,MAAM,CAAC,EAAE,KAAK,EAAE,IAAA,iBAAG,EAAQ,eAAe,EAAE,CAAC;iBAC7C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;iBACjB,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,MAAM,CAAC,KAAK,GAAG,WAAW,EAAE,KAAK,IAAI,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,gBAAgB,CAAC,MAAgB;QACvC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAE1C,MAAM,OAAO,GAA4B,EAAE,CAAC;QAC5C,wCAAwC;QACxC,OAAO,CAAC,EAAE,GAAI,IAAI,CAAC,MAAc,CAAC,EAAE,CAAC;QAErC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,KAAK,KAAK,IAAI;gBAAE,SAAS,CAAC,mBAAmB;YACjD,MAAM,GAAG,GAAI,IAAI,CAAC,MAAc,CAAC,KAAK,CAAC,CAAC;YACxC,IAAI,GAAG;gBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC;QAChC,CAAC;QAED,+CAA+C;QAC/C,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,MAAwB,EAAE,KAAc;QAClD,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAEvD,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,wBAAE;aACtB,MAAM,CAAC,EAAE,KAAK,EAAE,IAAA,iBAAG,EAAQ,eAAe,EAAE,CAAC;aAC7C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;aACjB,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QAExD,OAAO,MAAM,EAAE,KAAK,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAU,EAAE,KAAc;QACvC,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAEhD,MAAM,OAAO,GAAG,MAAM,wBAAE;aACrB,MAAM,EAAE;aACR,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;aACjB,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;aACzB,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAE/C,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAC5B,CAAC;IAED,sBAAsB;IAEtB;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,MAAc;QACxC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,wBAAE;aACvB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aACnB,MAAM,CAAC;YACN,GAAG,IAAI;YACP,SAAS,EAAE,MAAM,IAAI,QAAQ;YAC7B,SAAS,EAAE,MAAM,IAAI,QAAQ;SACvB,CAAC;aACR,kBAAkB,CAAC;YAClB,MAAM,EAAE,IAAI,CAAC,cAAqB;YAClC,GAAG,EAAE;gBACH,GAAG,IAAI;gBACP,SAAS,EAAE,IAAI,IAAI,EAAE;gBACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;aACvB;SACT,CAAC;aACD,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAElD,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QAErH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CACV,EAAU,EACV,IAAsB,EACtB,KAAa,EACb,MAAc;QAEd,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAEhD,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,wBAAE;aACvB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aACnB,GAAG,CAAC;YACH,GAAG,IAAI;YACP,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;SACvB,CAAC;aACR,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;aACzB,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAElD,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3H,CAAC;QAED,OAAO,OAAO,IAAI,IAAI,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,KAAa,EAAE,MAAc;QACpD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAEhD,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,wBAAE;aACvB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aACnB,GAAG,CAAC;YACH,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;YAC7B,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;SACvB,CAAC;aACR,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;aACzB,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAElD,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3H,CAAC;QAED,OAAO,OAAO,IAAI,IAAI,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CACd,OAAe,EACf,GAAW,EACX,EAAU,EACV,MAAc;QAEd,OAAO,wBAAE,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACjC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YACtC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9C,iDAAiD;YACjD,MAAM,eAAe,GAAG;gBACtB,IAAA,gBAAE,EAAC,SAAS,EAAE,GAAG,CAAC;gBAClB,IAAA,gBAAE,EAAE,IAAI,CAAC,MAAc,CAAC,SAAS,EAAE,IAAI,CAAC;aACzC,CAAC;YACF,IAAI,aAAa,EAAE,CAAC;gBAClB,eAAe,CAAC,IAAI,CAAC,IAAA,gBAAE,EAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;YACnD,CAAC;YAED,gFAAgF;YAChF,MAAM,EAAE,CAAC,OAAO,CACd,IAAA,iBAAG,EAAA,kBAAkB,IAAI,CAAC,MAAM;oBACpB,SAAS,MAAM,GAAG;oBACjB,IAAI,CAAC,MAAc,CAAC,SAAS;cACpC,aAAa,CAAC,CAAC,CAAC,IAAA,iBAAG,EAAA,OAAO,aAAa,MAAM,OAAO,EAAE,CAAC,CAAC,CAAC,IAAA,iBAAG,EAAA,EAAE;uBACrD,CAChB,CAAC;YAEF,4CAA4C;YAC5C,MAAM,EAAE;iBACL,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;iBACnB,GAAG,CAAC;gBACH,SAAS,EAAE,KAAK;gBAChB,SAAS,EAAE,IAAI,IAAI,EAAE;gBACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;aACvB,CAAC;iBACR,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,eAAe,CAAC,CAAC,CAAC;YAElC,sCAAsC;YACtC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE;iBACvB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;iBACnB,GAAG,CAAC;gBACH,SAAS,EAAE,IAAI;gBACf,SAAS,EAAE,IAAI,IAAI,EAAE;gBACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;aACvB,CAAC;iBACR,KAAK,CACJ,IAAA,iBAAG,EACD,IAAA,gBAAE,EAAE,IAAI,CAAC,MAAc,CAAC,EAAE,EAAE,EAAE,CAAC,EAC/B,IAAA,gBAAE,EAAC,SAAS,EAAE,GAAG,CAAC,CACnB,CACF;iBACA,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;YAElD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,wBAAa,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;YAC5D,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CACd,MAAwB,EACxB,IAAsB,EACtB,KAAa,EACb,MAAc;QAEd,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAEvD,OAAO,wBAAE;aACN,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aACnB,GAAG,CAAC;YACH,GAAG,IAAI;YACP,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,MAAM,IAAI,QAAQ;SACvB,CAAC;aACR,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;aACzB,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,KAAgB,EAAE,MAAc;QAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAElC,MAAM,UAAU,GAAG,GAAG,CAAC;QACvB,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,IAAI,GAAG,MAAM,IAAI,QAAQ,CAAC;QAEhC,MAAM,OAAO,GAAG,MAAM,wBAAE,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YAChD,MAAM,UAAU,GAAc,EAAE,CAAC;YAEjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC;gBAClD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;gBAC7C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBAChC,GAAG,IAAI;oBACP,SAAS,EAAE,IAAI;oBACf,SAAS,EAAE,IAAI;iBACR,CAAA,CAAC,CAAC;gBAEX,MAAM,OAAO,GAAG,MAAM,EAAE;qBACrB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;qBACnB,MAAM,CAAC,MAAM,CAAC;qBACd,kBAAkB,CAAC;oBAClB,MAAM,EAAE,IAAI,CAAC,cAAqB;oBAClC,GAAG,EAAE;wBACH,SAAS,EAAE,GAAG;wBACd,SAAS,EAAE,IAAI;qBACT;iBACT,CAAC;qBACD,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;gBAElD,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;YAC9B,CAAC;YAED,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACtH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CACd,GAAa,EACb,KAAa,EACb,MAAc;QAEd,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAEhC,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,IAAI,GAAG,MAAM,IAAI,QAAQ,CAAC;QAChC,MAAM,UAAU,GAAG;YACjB,IAAA,qBAAO,EAAE,IAAI,CAAC,MAAc,CAAC,EAAE,EAAE,GAAG,CAAC;YACrC,GAAG,IAAI,CAAC,eAAe,CAAC,EAAsB,EAAE,KAAK,CAAC;SACvD,CAAC;QAEF,MAAM,OAAO,GAAG,MAAM,wBAAE;aACrB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aACnB,GAAG,CAAC;YACH,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,GAAG;YACd,SAAS,EAAE,IAAI;YACf,SAAS,EAAE,GAAG;YACd,SAAS,EAAE,IAAI;SACT,CAAC;aACR,KAAK,CAAC,IAAA,iBAAG,EAAC,GAAG,UAAU,CAAC,CAAC;aACzB,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;QAElD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACjI,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AA5bD,kCA4bC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { NotFoundError, createLogger } from '@pipeline-builder/api-core';\nimport { SQL, eq, and, asc, desc, sql, inArray } from 'drizzle-orm';\nimport type { AnyColumn } from 'drizzle-orm/column';\nimport type { PgTable } from 'drizzle-orm/pg-core';\nimport { db } from '../database/postgres-connection';\n\n/** Pagination defaults — read from env to match CoreConstants in pipeline-core. */\nconst DEFAULT_PAGE_LIMIT = parseInt(process.env.DEFAULT_PAGE_LIMIT || '100', 10);\nconst MAX_PAGE_LIMIT = parseInt(process.env.MAX_PAGE_LIMIT || '1000', 10);\n\n/**\n * Cast Drizzle query results to a typed array.\n * Drizzle's generic return type (`PgSelectBase<...>`) doesn't narrow to our\n * entity generics, so an explicit cast is needed. Centralised here so every\n * call-site stays one-liner clean and the cast is documented in one place.\n */\nexport function drizzleRows<T>(rows: unknown): T[] {\n  return rows as T[];\n}\n\n/** Cast a Drizzle aggregate result to extract `[{ count: number }]`. */\nexport function drizzleCount(rows: unknown): [{ count: number }] {\n  return rows as [{ count: number }];\n}\n\n/**\n * Base interface for entities with common fields\n */\nexport interface BaseEntity {\n  id: string;\n  orgId: string;\n  isDefault: boolean;\n  createdAt: Date;\n  updatedAt: Date;\n  createdBy: string;\n  updatedBy: string;\n  [key: string]: unknown;\n}\n\n/**\n * Pagination and sorting options\n */\nexport interface QueryOptions {\n  limit?: number;\n  offset?: number;\n  sortBy?: string;\n  sortOrder?: 'asc' | 'desc';\n  /** When true, runs a separate COUNT(*) query to include exact total. Default: false. */\n  includeTotal?: boolean;\n  /** Cursor-based pagination: fetch rows after this cursor value (uses sortBy column). */\n  cursor?: string;\n  /** Sparse fieldset: column names to select. Returns all columns when omitted. */\n  fields?: string[];\n}\n\n/**\n * Paginated result with metadata\n */\nexport interface PaginatedResult<T> {\n  data: T[];\n  /** Total count of matching entities. Only present when includeTotal is true. */\n  total?: number;\n  limit: number;\n  offset: number;\n  hasMore: boolean;\n  /** Cursor pointing to the last item, for cursor-based pagination. */\n  nextCursor?: string;\n}\n\n/**\n * Abstract CRUD service with access control and common operations.\n *\n * @typeParam TEntity - Entity type extending BaseEntity\n * @typeParam TFilter - Filter type for query parameters\n * @typeParam TInsert - Insert DTO type\n * @typeParam TUpdate - Update DTO type\n *\n * Type assertions (`as any`, `as unknown as T`) are used throughout for Drizzle ORM compatibility.\n * This is safe because: access control filters by orgId, schema validation is at the DB level,\n * and each subclass is tested for type correctness.\n *\n * Errors are not caught here — they propagate to the route-level error handler (`withRoute`)\n * which provides consistent logging with request context.\n *\n * @example\n * ```typescript\n * class PipelineService extends CrudService<Pipeline, PipelineFilter, PipelineInsert, PipelineUpdate> {\n *   protected get schema() { return schema.pipeline; }\n *   protected buildConditions(filter, orgId) { return buildPipelineConditions(filter, orgId); }\n *   protected getSortColumn(sortBy) { return sortColumnMap[sortBy] ?? null; }\n *   protected getProjectColumn() { return schema.pipeline.project; }\n *   protected getOrgColumn() { return schema.pipeline.organization; }\n * }\n * ```\n */\nexport abstract class CrudService<\n  TEntity extends BaseEntity,\n  TFilter,\n  TInsert,\n  TUpdate,\n> {\n  /** Drizzle schema table for this entity */\n  protected abstract get schema(): PgTable;\n\n  /** Build SQL conditions for filtering entities */\n  protected abstract buildConditions(filter: Partial<TFilter>, orgId?: string): SQL[];\n\n  /** Get the schema column for sorting by field name */\n  protected abstract getSortColumn(sortBy: string): AnyColumn | null;\n\n  /** Get the project column for setDefault scoping (null if entity has no project scope) */\n  protected abstract getProjectColumn(): AnyColumn | null;\n\n  /** Get the organization column for setDefault scoping */\n  protected abstract getOrgColumn(): AnyColumn;\n\n  /** Get the unique constraint columns for onConflictDoUpdate */\n  protected abstract get conflictTarget(): AnyColumn[];\n\n  private readonly _logger = createLogger('CrudService');\n\n  /** Build conditions for a single entity by ID. */\n  private idConditions(id: string, orgId?: string): SQL[] {\n    return this.buildConditions({ id } as unknown as Partial<TFilter>, orgId);\n  }\n\n  // Lifecycle hooks — override in subclasses to react to mutations\n  // These are fire-and-forget: errors are logged but never block the caller.\n\n  /** Called after a new entity is created */\n  protected async onAfterCreate(_entity: TEntity, _userId: string): Promise<void> {}\n\n  /** Called after an entity is updated */\n  protected async onAfterUpdate(_id: string, _entity: TEntity, _userId: string): Promise<void> {}\n\n  /** Called after an entity is soft-deleted */\n  protected async onAfterDelete(_id: string, _entity: TEntity, _userId: string): Promise<void> {}\n\n  /**\n   * Find entities matching filter criteria\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)\n   */\n  async find(filter: Partial<TFilter>, orgId?: string): Promise<TEntity[]> {\n    const conditions = this.buildConditions(filter, orgId);\n\n    return db\n      .select()\n      .from(this.schema)\n      .where(and(...conditions)).then(r => drizzleRows<TEntity>(r));\n  }\n\n  /**\n   * Find entities with pagination and sorting\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)\n   * @param options - Pagination and sorting options\n   */\n  async findPaginated(\n    filter: Partial<TFilter>,\n    orgId?: string,\n    options: QueryOptions = {},\n  ): Promise<PaginatedResult<TEntity>> {\n    const { limit: rawLimit = DEFAULT_PAGE_LIMIT, offset = 0, sortBy, sortOrder = 'asc', includeTotal = false, cursor, fields } = options;\n    const limit = Math.min(Math.max(1, rawLimit), MAX_PAGE_LIMIT);\n\n    // Cursor and offset are mutually exclusive — cursor takes precedence\n    const useCursor = !!(cursor && sortBy);\n\n    const conditions = this.buildConditions(filter, orgId);\n\n    // Cursor-based pagination: add WHERE clause for keyset pagination\n    if (useCursor) {\n      const sortColumn = this.getSortColumn(sortBy);\n      if (sortColumn) {\n        const op = sortOrder === 'desc'\n          ? sql`${sortColumn} < ${cursor}`\n          : sql`${sortColumn} > ${cursor}`;\n        conditions.push(op);\n      }\n    }\n\n    // Build SELECT — sparse fieldset when fields are specified\n    const selectSpec = fields ? this.buildFieldSelect(fields) : undefined;\n    let query = selectSpec\n      ? db.select(selectSpec as any).from(this.schema).where(and(...conditions))\n      : db.select().from(this.schema).where(and(...conditions));\n\n    if (sortBy) {\n      const sortColumn = this.getSortColumn(sortBy);\n      if (sortColumn) {\n        query = query.orderBy(sortOrder === 'desc' ? desc(sortColumn) : asc(sortColumn)) as any;\n      }\n    }\n\n    // Fetch limit+1 to detect hasMore without COUNT(*)\n    const effectiveOffset = useCursor ? 0 : offset;\n    const rows = await query\n      .limit(limit + 1)\n      .offset(effectiveOffset).then(r => drizzleRows<TEntity>(r));\n\n    const hasMore = rows.length > limit;\n    const data = hasMore ? rows.slice(0, limit) : rows;\n\n    const result: PaginatedResult<TEntity> = { data, limit, offset: effectiveOffset, hasMore };\n\n    // Provide next cursor from last item's sort column value\n    if (data.length > 0 && sortBy) {\n      const lastItem = data[data.length - 1] as Record<string, unknown>;\n      const cursorValue = lastItem[sortBy];\n      if (cursorValue !== undefined) {\n        result.nextCursor = cursorValue instanceof Date ? cursorValue.toISOString() : String(cursorValue);\n      }\n    }\n\n    // Only run the COUNT(*) query when the caller explicitly needs the total\n    if (includeTotal) {\n      const baseConditions = this.buildConditions(filter, orgId);\n      const [countResult] = await db\n        .select({ count: sql<number>`count(*)::int` })\n        .from(this.schema)\n        .where(and(...baseConditions)).then(r => drizzleCount(r));\n      result.total = countResult?.count || 0;\n    }\n\n    return result;\n  }\n\n  /**\n   * Build a column selection map for sparse fieldsets.\n   * Falls back to full select if no matching columns found.\n   */\n  private buildFieldSelect(fields: string[]): Record<string, unknown> | undefined {\n    if (fields.length === 0) return undefined;\n\n    const columns: Record<string, unknown> = {};\n    // Always include id for entity identity\n    columns.id = (this.schema as any).id;\n\n    for (const field of fields) {\n      if (field === 'id') continue; // Already included\n      const col = (this.schema as any)[field];\n      if (col) columns[field] = col;\n    }\n\n    // At minimum we'll have { id }, which is valid\n    return columns;\n  }\n\n  /**\n   * Count entities matching filter criteria\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)\n   */\n  async count(filter: Partial<TFilter>, orgId?: string): Promise<number> {\n    const conditions = this.buildConditions(filter, orgId);\n\n    const [result] = await db\n      .select({ count: sql<number>`count(*)::int` })\n      .from(this.schema)\n      .where(and(...conditions)).then(r => drizzleCount(r));\n\n    return result?.count || 0;\n  }\n\n  /**\n   * Find a single entity by ID\n   *\n   * @param id - Entity ID\n   * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)\n   */\n  async findById(id: string, orgId?: string): Promise<TEntity | null> {\n    const conditions = this.idConditions(id, orgId);\n\n    const results = await db\n      .select()\n      .from(this.schema)\n      .where(and(...conditions))\n      .limit(1).then(r => drizzleRows<TEntity>(r));\n\n    return results[0] || null;\n  }\n\n  // Mutation operations\n\n  /**\n   * Create a new entity\n   */\n  async create(data: TInsert, userId: string): Promise<TEntity> {\n    const [created] = await db\n      .insert(this.schema)\n      .values({\n        ...data,\n        createdBy: userId || 'system',\n        updatedBy: userId || 'system',\n      } as any)\n      .onConflictDoUpdate({\n        target: this.conflictTarget as any,\n        set: {\n          ...data,\n          updatedAt: new Date(),\n          updatedBy: userId || 'system',\n        } as any,\n      })\n      .returning().then(r => drizzleRows<TEntity>(r));\n\n    this.onAfterCreate(created, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));\n\n    return created;\n  }\n\n  /**\n   * Update an existing entity\n   */\n  async update(\n    id: string,\n    data: Partial<TUpdate>,\n    orgId: string,\n    userId: string,\n  ): Promise<TEntity | null> {\n    const conditions = this.idConditions(id, orgId);\n\n    const [updated] = await db\n      .update(this.schema)\n      .set({\n        ...data,\n        updatedAt: new Date(),\n        updatedBy: userId || 'system',\n      } as any)\n      .where(and(...conditions))\n      .returning().then(r => drizzleRows<TEntity>(r));\n\n    if (updated) {\n      this.onAfterUpdate(id, updated, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));\n    }\n\n    return updated || null;\n  }\n\n  /**\n   * Delete an entity (soft delete by setting isActive = false)\n   */\n  async delete(id: string, orgId: string, userId: string): Promise<TEntity | null> {\n    const conditions = this.idConditions(id, orgId);\n\n    const [deleted] = await db\n      .update(this.schema)\n      .set({\n        isActive: false,\n        updatedAt: new Date(),\n        updatedBy: userId || 'system',\n        deletedAt: new Date(),\n        deletedBy: userId || 'system',\n      } as any)\n      .where(and(...conditions))\n      .returning().then(r => drizzleRows<TEntity>(r));\n\n    if (deleted) {\n      this.onAfterDelete(id, deleted, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));\n    }\n\n    return deleted || null;\n  }\n\n  /**\n   * Set an entity as the default for a project/organization scope.\n   * Marks all other entities as non-default, then sets the specified entity.\n   * Uses a transaction to ensure atomicity.\n   */\n  async setDefault(\n    project: string,\n    org: string,\n    id: string,\n    userId: string,\n  ): Promise<TEntity> {\n    return db.transaction(async (tx) => {\n      const orgColumn = this.getOrgColumn();\n      const projectColumn = this.getProjectColumn();\n\n      // Build scoping conditions for clearing defaults\n      const scopeConditions = [\n        eq(orgColumn, org),\n        eq((this.schema as any).isDefault, true),\n      ];\n      if (projectColumn) {\n        scopeConditions.push(eq(projectColumn, project));\n      }\n\n      // Lock existing defaults with FOR UPDATE to prevent concurrent setDefault races\n      await tx.execute(\n        sql`SELECT id FROM ${this.schema}\n            WHERE ${orgColumn} = ${org}\n              AND ${(this.schema as any).isDefault} = true\n            ${projectColumn ? sql`AND ${projectColumn} = ${project}` : sql``}\n            FOR UPDATE`,\n      );\n\n      // Mark all entities in scope as non-default\n      await tx\n        .update(this.schema)\n        .set({\n          isDefault: false,\n          updatedAt: new Date(),\n          updatedBy: userId || 'system',\n        } as any)\n        .where(and(...scopeConditions));\n\n      // Set the specified entity as default\n      const [updated] = await tx\n        .update(this.schema)\n        .set({\n          isDefault: true,\n          updatedAt: new Date(),\n          updatedBy: userId || 'system',\n        } as any)\n        .where(\n          and(\n            eq((this.schema as any).id, id),\n            eq(orgColumn, org),\n          ),\n        )\n        .returning().then(r => drizzleRows<TEntity>(r));\n\n      if (!updated) {\n        throw new NotFoundError(`Entity with id ${id} not found`);\n      }\n\n      return updated;\n    });\n  }\n\n  /**\n   * Update multiple entities matching filter\n   */\n  async updateMany(\n    filter: Partial<TFilter>,\n    data: Partial<TUpdate>,\n    orgId: string,\n    userId: string,\n  ): Promise<TEntity[]> {\n    const conditions = this.buildConditions(filter, orgId);\n\n    return db\n      .update(this.schema)\n      .set({\n        ...data,\n        updatedAt: new Date(),\n        updatedBy: userId || 'system',\n      } as any)\n      .where(and(...conditions))\n      .returning().then(r => drizzleRows<TEntity>(r));\n  }\n\n  /**\n   * Create multiple entities in a single batch insert.\n   * Uses upsert (onConflictDoUpdate) — all rows are inserted in one query per chunk.\n   * Chunks of 100 to stay within PostgreSQL parameter limits.\n   */\n  async bulkCreate(items: TInsert[], userId: string): Promise<TEntity[]> {\n    if (items.length === 0) return [];\n\n    const CHUNK_SIZE = 100;\n    const now = new Date();\n    const user = userId || 'system';\n\n    const results = await db.transaction(async (tx) => {\n      const allCreated: TEntity[] = [];\n\n      for (let i = 0; i < items.length; i += CHUNK_SIZE) {\n        const chunk = items.slice(i, i + CHUNK_SIZE);\n        const values = chunk.map(data => ({\n          ...data,\n          createdBy: user,\n          updatedBy: user,\n        } as any));\n\n        const created = await tx\n          .insert(this.schema)\n          .values(values)\n          .onConflictDoUpdate({\n            target: this.conflictTarget as any,\n            set: {\n              updatedAt: now,\n              updatedBy: user,\n            } as any,\n          })\n          .returning().then(r => drizzleRows<TEntity>(r));\n\n        allCreated.push(...created);\n      }\n\n      return allCreated;\n    });\n\n    for (const entity of results) {\n      this.onAfterCreate(entity, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));\n    }\n\n    return results;\n  }\n\n  /**\n   * Soft-delete multiple entities by IDs in a single batch operation.\n   */\n  async bulkDelete(\n    ids: string[],\n    orgId: string,\n    userId: string,\n  ): Promise<TEntity[]> {\n    if (ids.length === 0) return [];\n\n    const now = new Date();\n    const user = userId || 'system';\n    const conditions = [\n      inArray((this.schema as any).id, ids),\n      ...this.buildConditions({} as Partial<TFilter>, orgId),\n    ];\n\n    const deleted = await db\n      .update(this.schema)\n      .set({\n        isActive: false,\n        updatedAt: now,\n        updatedBy: user,\n        deletedAt: now,\n        deletedBy: user,\n      } as any)\n      .where(and(...conditions))\n      .returning().then(r => drizzleRows<TEntity>(r));\n\n    for (const entity of deleted) {\n      this.onAfterDelete(entity.id, entity, userId).catch(err => this._logger.warn('Lifecycle hook failed', { error: String(err) }));\n    }\n\n    return deleted;\n  }\n}\n"]}