@wildo-ai/saas-backend-lib 1.0.1

package/dist/esm/base-classes/services/repositories/postgresql-resource-repository.backend.service.js

@@ -0,0 +1,800 @@
+import { CoreResourceOperation, ErrorCustomMessageReference, ErrorType, ResourceOperationsUtils, ResourcesConfig_OperationPathUtils, } from '@wildo-ai/saas-models';
+import { PostgreSQLFilterBackendService } from '../../../databases/services/postgresql-filter.backend.service.js';
+import { sql } from 'kysely';
+/**
+ * PostgreSQL Repository Skeleton (Hybrid JSONB + Kysely)
+ *
+ * NOTE:
+ * - This is a scaffolding class to be completed in the next steps.
+ * - It mirrors `RepositoryResourceBackendService` construction (per resourceType),
+ *   but targets PostgreSQL via Kysely.
+ * - Migrations/DDL are owned by apps-manager.
+ */
+export class PostgreSQLResourceRepositoryBackendService {
+    dbService;
+    logger;
+    errorBuilder;
+    resourceRegistry;
+    resourceOperationHelper;
+    repositoriesRegistry;
+    sqlPlanner;
+    resourceIdService;
+    resourceConfiguration;
+    filterService;
+    jsonbRoots;
+    tableName;
+    operationsMap;
+    plannedFieldNames;
+    logDebug;
+    constructor(resourceType, dbService, logger, errorBuilder, resourceRegistry, resourceOperationHelper, repositoriesRegistry, sqlPlanner, resourceIdService) {
+        this.dbService = dbService;
+        this.logger = logger;
+        this.errorBuilder = errorBuilder;
+        this.resourceRegistry = resourceRegistry;
+        this.resourceOperationHelper = resourceOperationHelper;
+        this.repositoriesRegistry = repositoriesRegistry;
+        this.sqlPlanner = sqlPlanner;
+        this.resourceIdService = resourceIdService;
+        this.resourceConfiguration = this.resourceRegistry.getResourceConfiguration(resourceType);
+        this.logDebug = this.logger.debugByType(`PostgreSQLRepositoryResource_${resourceType}`);
+        this.logger.setDebugTypeLogging(`PostgreSQLRepositoryResource_${resourceType}`, false);
+        // Configure JSONB roots for dot-notation support:
+        // - always include variantConfig for hybrid inheritance
+        // - include any object/array fields planned as JSONB
+        const planned = this.sqlPlanner.planSqlHybridTable(this.resourceConfiguration, this.resourceConfiguration.mainSchema);
+        this.jsonbRoots = new Set(planned.fields.filter((f) => f.storage === 'jsonb').map((f) => f.name));
+        this.jsonbRoots.add('variantConfig');
+        this.plannedFieldNames = new Set(planned.fields.map((f) => f.name));
+        this.filterService = new PostgreSQLFilterBackendService(this.logger, this.errorBuilder);
+        this.filterService.setJsonbFields(this.jsonbRoots);
+        this.tableName = PostgreSQLFilterBackendService.normalizeTableName(String(this.resourceConfiguration.resourceIdentifier));
+        this.operationsMap = new Map();
+        this.initializeOperationsMap();
+        this.logDebug('PostgreSQL repository skeleton created', {
+            resourceType: this.resourceConfiguration.resourceIdentifier,
+            tableName: this.tableName,
+            jsonbRoots: Array.from(this.jsonbRoots),
+        });
+    }
+    /**
+     * Extract native SQL transaction client from RepositoryOptions (if any).
+     * Includes a runtime safety check similar to Mongo repository.
+     */
+    getTransaction(options) {
+        if (!options?.transaction)
+            return undefined;
+        if (options.transaction.databaseType !== 'postgresql') {
+            throw new Error(`PostgreSQL repository received non-PostgreSQL transaction. ` +
+                `Expected databaseType='postgresql', got '${options.transaction.databaseType}'.`);
+        }
+        return options.transaction;
+    }
+    /**
+     * Build a SQL where expression from a Mongo-style filter.
+     */
+    buildWhere(filter) {
+        return this.filterService.buildWhereExpression(filter);
+    }
+    // ===========================================================================
+    // Operation routing (align with Mongo repository surface)
+    // ===========================================================================
+    async doByPath(operationRepositoryPath, executionContext, id_or_ids_or_filter, data, options) {
+        const key = ResourcesConfig_OperationPathUtils.createOperationRepositoryPathKey(operationRepositoryPath);
+        return this.doByKey(key, executionContext, id_or_ids_or_filter, data, options);
+    }
+    async doByKey(operationRepositoryPathKey, executionContext, id_or_ids_or_filter, data, options) {
+        ResourcesConfig_OperationPathUtils.validateOperationRepositoryPathKey(operationRepositoryPathKey);
+        const operation = this.operationsMap.get(operationRepositoryPathKey);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.NOT_FOUND, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationRepositoryPathKey },
+            });
+        }
+        return (await this.doOperation(operation, executionContext, id_or_ids_or_filter, data, options));
+    }
+    async doByExecutionContext(executionContext, data, options) {
+        const operation = executionContext.operation;
+        const id_or_ids_or_filter = this.resourceOperationHelper.extractIdsFromExecutionContext(executionContext, this.resourceConfiguration.resourceFieldIdentifier);
+        return (await this.doOperation(operation, executionContext, id_or_ids_or_filter, data, options));
+    }
+    async doOperation(operation, executionContext, id_or_ids_or_filter, data, options) {
+        const operationRepositoryPathKey = ResourcesConfig_OperationPathUtils.createOperationRepositoryPathKeyFromOperation(operation);
+        if (operation.resourceIdentifier !== this.resourceConfiguration.resourceIdentifier) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationRepositoryPathKey, resourceIdentifier: this.resourceConfiguration.resourceIdentifier },
+            });
+        }
+        const opIdentifier = ResourceOperationsUtils.getCoreResourceOperationFromOperation(operation);
+        if (!opIdentifier) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationRepositoryPathKey },
+            });
+        }
+        switch (opIdentifier) {
+            case CoreResourceOperation.CREATE:
+                return this._doCreate(operation, executionContext, data, options);
+            case CoreResourceOperation.CREATE_MANY:
+                return this._doCreateMany(operation, executionContext, data, options);
+            case CoreResourceOperation.READ:
+                if (Array.isArray(id_or_ids_or_filter)) {
+                    throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                        customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                        context: { operationRepositoryPathKey, id_or_ids_or_filter },
+                    });
+                }
+                return this._doRead(operation, executionContext, id_or_ids_or_filter, options);
+            case CoreResourceOperation.UPDATE:
+                if (Array.isArray(id_or_ids_or_filter)) {
+                    throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                        customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                        context: { operationRepositoryPathKey, id_or_ids_or_filter },
+                    });
+                }
+                return this._doUpdate(operation, executionContext, id_or_ids_or_filter, data, options);
+            case CoreResourceOperation.UPDATE_MANY:
+                return this._doUpdateMany(operation, executionContext, id_or_ids_or_filter, data, options);
+            case CoreResourceOperation.DELETE:
+                if (Array.isArray(id_or_ids_or_filter)) {
+                    throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                        customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                        context: { operationRepositoryPathKey, id_or_ids_or_filter },
+                    });
+                }
+                return this._doDelete(operation, executionContext, id_or_ids_or_filter, options);
+            case CoreResourceOperation.DELETE_MANY:
+                return this._doDeleteMany(operation, executionContext, id_or_ids_or_filter, options);
+            case CoreResourceOperation.LIST:
+                return this._doList(operation, executionContext, id_or_ids_or_filter, options);
+            case CoreResourceOperation.COUNT:
+                return this._doCount(operation, executionContext, id_or_ids_or_filter, options);
+            case CoreResourceOperation.SEARCH:
+                return this._doSearch(operation, executionContext, data?.query || '', {}, options);
+            default:
+                throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                    customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                    context: { resourceIdentifier: this.resourceConfiguration.resourceIdentifier, opIdentifier },
+                });
+        }
+    }
+    initializeOperationsMap() {
+        const ops = this.resourceConfiguration.operations || [];
+        for (const operation of ops) {
+            const key = ResourcesConfig_OperationPathUtils.createOperationRepositoryPathKeyFromOperation(operation);
+            if (this.operationsMap.has(key)) {
+                this.logger.warn(`Duplicate repository operation key '${key}' for resource '${String(this.resourceConfiguration.resourceIdentifier)}'. Last operation wins.`);
+            }
+            this.operationsMap.set(key, operation);
+        }
+    }
+    // The method surface should mirror the Mongo repository public API so the
+    // service layer can remain database-agnostic.
+    //
+    // Implementation will:
+    // - Use this.dbService.getDb() to get a Kysely instance
+    // - Apply SqlWhereExpression compilation to Kysely query builder
+    // - Apply hybrid transforms via sqlPlanner.transformForSqlWrite/transformFromSqlRead
+    // - Respect RepositoryOptions.transaction (nativeSession contains transaction client)
+    // NOTE: These signatures are intentionally aligned with the resource-system expectations
+    // but kept minimal for initial PostgreSQL adapter bring-up.
+    async create(executionContext, data, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.CREATE && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.CREATE },
+            });
+        }
+        return this._doCreate(operation, executionContext, data, options);
+    }
+    async createMany(executionContext, data, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.CREATE_MANY && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.CREATE_MANY },
+            });
+        }
+        return this._doCreateMany(operation, executionContext, data, options);
+    }
+    async read(executionContext, id_or_filter, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.READ && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.READ },
+            });
+        }
+        return this._doRead(operation, executionContext, id_or_filter, options);
+    }
+    async update(executionContext, id_or_filter, data, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.UPDATE && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.UPDATE },
+            });
+        }
+        return this._doUpdate(operation, executionContext, id_or_filter, data, options);
+    }
+    async updateMany(executionContext, data, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.UPDATE_MANY && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.UPDATE_MANY },
+            });
+        }
+        return this._doUpdateMany(operation, executionContext, undefined, data, options);
+    }
+    async delete(executionContext, id_or_ids_or_filter, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.DELETE && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.DELETE },
+            });
+        }
+        const deleted = await this._doDelete(operation, executionContext, id_or_ids_or_filter, options);
+        return deleted?._id ?? deleted?.id ?? '';
+    }
+    async deleteMany(executionContext, ids_or_filter, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.DELETE_MANY && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.DELETE_MANY },
+            });
+        }
+        return this._doDeleteMany(operation, executionContext, ids_or_filter, options);
+    }
+    async list(executionContext, ids_or_filter, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.LIST && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.LIST },
+            });
+        }
+        return this._doList(operation, executionContext, ids_or_filter, options);
+    }
+    async search(executionContext, searchQuery, filter = {}, searchOptions = {}, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.SEARCH && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.SEARCH },
+            });
+        }
+        return this._doSearch(operation, executionContext, searchQuery, filter, { ...options, searchOptions });
+    }
+    async count(executionContext, filter = {}, options) {
+        const operation = this.resourceConfiguration.operations.find((op) => op.operationIdentifier === CoreResourceOperation.COUNT && op.isDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.COUNT },
+            });
+        }
+        return this._doCount(operation, executionContext, filter, options);
+    }
+    supportsOperation(operationIdentifier) {
+        return this.resourceConfiguration.operations.some((op) => op.operationIdentifier === operationIdentifier && op.isDefault);
+    }
+    // ===========================================================================
+    // Core private ops (initial subset)
+    // ===========================================================================
+    async _doCreate(operation, executionContext, data, options) {
+        const cleaned = this.resourceOperationHelper.cleanInputData(data, CoreResourceOperation.CREATE);
+        const validated = this.repositoriesRegistry.validateRequestData(cleaned, this.resourceConfiguration.resourceIdentifier, CoreResourceOperation.CREATE);
+        const enriched = this.resourceOperationHelper.enrichDataWithContext(validated, executionContext, this.resourceConfiguration.mainSchema, this.resourceConfiguration.resourceFieldIdentifier, CoreResourceOperation.CREATE, options);
+        if (executionContext.isAnonymousExecution() && this.resourceConfiguration.isAnonymizable) {
+            enriched.userId = null;
+        }
+        const withLiterals = this.resourceOperationHelper.injectNonDiscriminatorLiteralValues(enriched, this.resourceConfiguration.mainSchema);
+        const withTracking = this.addUserTrackingAndTimestamps(withLiterals, executionContext, CoreResourceOperation.CREATE);
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const toWrite = this.sqlPlanner.transformForSqlWrite(withTracking, inheritanceDef);
+        const inserted = await db
+            .insertInto(this.tableName)
+            .values(toWrite)
+            .returningAll()
+            .executeTakeFirst();
+        if (!inserted)
+            return null;
+        return this.sqlPlanner.transformFromSqlRead(inserted, inheritanceDef);
+    }
+    async _doCreateMany(operation, executionContext, data, options) {
+        const dataArray = Array.isArray(data) ? data : [];
+        const cleanedArray = this.resourceOperationHelper.cleanInputDataArray(dataArray, CoreResourceOperation.CREATE_MANY);
+        const isBulkOperation = 'isBulkOperation' in operation && operation.isBulkOperation === true;
+        const validatedArray = cleanedArray.map((item) => this.repositoriesRegistry.validateRepositoryWriteData(item, this.resourceConfiguration.resourceIdentifier, String(operation.operationIdentifier), isBulkOperation));
+        const isAnonymousCreate = executionContext.isAnonymousExecution() && this.resourceConfiguration.isAnonymizable;
+        const enrichedArray = (Array.isArray(validatedArray) ? validatedArray : []).map((item) => {
+            const enriched = this.resourceOperationHelper.enrichDataWithContext(item, executionContext, this.resourceConfiguration.mainSchema, this.resourceConfiguration.resourceFieldIdentifier, CoreResourceOperation.CREATE_MANY, options);
+            if (isAnonymousCreate) {
+                enriched.userId = null;
+            }
+            return enriched;
+        });
+        const withLiteralsArray = enrichedArray.map((item) => this.resourceOperationHelper.injectNonDiscriminatorLiteralValues(item, this.resourceConfiguration.mainSchema));
+        const withTrackingArray = withLiteralsArray.map((item) => this.addUserTrackingAndTimestamps(item, executionContext, CoreResourceOperation.CREATE));
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const toWriteArray = withTrackingArray.map((item) => this.sqlPlanner.transformForSqlWrite(item, inheritanceDef));
+        if (toWriteArray.length === 0)
+            return [];
+        const insertedRows = await db.insertInto(this.tableName).values(toWriteArray).returningAll().execute();
+        return insertedRows.map((row) => this.sqlPlanner.transformFromSqlRead(row, inheritanceDef));
+    }
+    async _doRead(operation, executionContext, id_or_filter, options) {
+        // Align with Mongo behavior: READ requires an id or filter.
+        if (!id_or_filter) {
+            throw this.errorBuilder.buildError(ErrorType.VALIDATION, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { operationIdentifier: CoreResourceOperation.READ, message: 'READ requires an id_or_filter' },
+            });
+        }
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const { baseFilter } = this.buildBaseFilterFromIdOrFilter(id_or_filter, executionContext);
+        const contextualFilter = this.buildContextualFilter(executionContext, baseFilter, options);
+        const where = this.buildWhere(contextualFilter);
+        const qb = this.filterService.applyWhere(db.selectFrom(this.tableName).selectAll(), where);
+        const row = await qb.executeTakeFirst();
+        if (!row)
+            return null;
+        return this.sqlPlanner.transformFromSqlRead(row, inheritanceDef);
+    }
+    async _doUpdate(operation, executionContext, id_or_filter, data, options) {
+        const { baseFilter } = this.buildBaseFilterFromIdOrFilter(id_or_filter, executionContext);
+        const id = await this.resolveSingleId(executionContext, baseFilter, options);
+        if (!id)
+            return null;
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const cleaned = this.resourceOperationHelper.cleanInputData(data, CoreResourceOperation.UPDATE);
+        const isBulkOperation = 'isBulkOperation' in operation && operation.isBulkOperation === true;
+        const validated = this.repositoriesRegistry.validateRepositoryWriteData(cleaned, this.resourceConfiguration.resourceIdentifier, String(operation.operationIdentifier), isBulkOperation);
+        const enriched = this.resourceOperationHelper.enrichDataWithContext(validated, executionContext, this.resourceConfiguration.mainSchema, this.resourceConfiguration.resourceFieldIdentifier, CoreResourceOperation.UPDATE, options);
+        const withTracking = this.addUserTrackingAndTimestamps(enriched, executionContext, CoreResourceOperation.UPDATE);
+        const toWrite = this.sqlPlanner.transformForSqlWrite(withTracking, inheritanceDef);
+        const contextualFilter = this.buildContextualFilter(executionContext, { _id: id }, options);
+        const scopedWhere = this.buildWhere(contextualFilter);
+        const updated = await db
+            .updateTable(this.tableName)
+            .set(toWrite)
+            .$call((qb) => this.filterService.applyWhere(qb, scopedWhere))
+            .returningAll()
+            .executeTakeFirst();
+        if (!updated)
+            return null;
+        return this.sqlPlanner.transformFromSqlRead(updated, inheritanceDef);
+    }
+    async _doDelete(operation, executionContext, id_or_ids_or_filter, options) {
+        const { baseFilter } = this.buildBaseFilterFromIdOrFilter(id_or_ids_or_filter, executionContext);
+        const id = await this.resolveSingleId(executionContext, baseFilter, options);
+        if (!id)
+            return null;
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const contextualFilter = this.buildContextualFilter(executionContext, { _id: id }, options);
+        const scopedWhere = this.buildWhere(contextualFilter);
+        const deleted = await db
+            .deleteFrom(this.tableName)
+            .$call((qb) => this.filterService.applyWhere(qb, scopedWhere))
+            .returningAll()
+            .executeTakeFirst();
+        if (!deleted)
+            return null;
+        return this.sqlPlanner.transformFromSqlRead(deleted, inheritanceDef);
+    }
+    async _doDeleteMany(operation, executionContext, ids_or_filter, options) {
+        const db = await this.getDbOrTrx(options);
+        const filter = this.normalizeIdsOrFilter(ids_or_filter);
+        const contextualFilter = this.buildContextualFilter(executionContext, filter, options);
+        const where = this.buildWhere(contextualFilter);
+        // Return deleted ids (best-effort; depends on table having _id)
+        const deletedRows = await db
+            .deleteFrom(this.tableName)
+            .$call((qb) => this.filterService.applyWhere(qb, where))
+            .returning(['_id'])
+            .execute();
+        return (deletedRows || [])
+            .map((r) => r?._id)
+            .filter((v) => typeof v === 'string' && v.length > 0);
+    }
+    async _doUpdateMany(operation, executionContext, ids_or_filter, data, options) {
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const cleaned = this.resourceOperationHelper.cleanInputData(data, CoreResourceOperation.UPDATE_MANY);
+        const isBulkOperation = 'isBulkOperation' in operation && operation.isBulkOperation === true;
+        const validated = this.repositoriesRegistry.validateRepositoryWriteData(cleaned, this.resourceConfiguration.resourceIdentifier, String(operation.operationIdentifier), isBulkOperation);
+        const enriched = this.resourceOperationHelper.enrichDataWithContext(validated, executionContext, this.resourceConfiguration.mainSchema, this.resourceConfiguration.resourceFieldIdentifier, CoreResourceOperation.UPDATE_MANY, options);
+        const withTracking = this.addUserTrackingAndTimestamps(enriched, executionContext, CoreResourceOperation.UPDATE);
+        const toWrite = this.sqlPlanner.transformForSqlWrite(withTracking, inheritanceDef);
+        const filter = this.normalizeIdsOrFilter(ids_or_filter);
+        const contextualFilter = this.buildContextualFilter(executionContext, filter, options);
+        const where = this.buildWhere(contextualFilter);
+        const updatedRows = await db
+            .updateTable(this.tableName)
+            .set(toWrite)
+            .$call((qb) => this.filterService.applyWhere(qb, where))
+            .returningAll()
+            .execute();
+        return (updatedRows || []).map((row) => this.sqlPlanner.transformFromSqlRead(row, inheritanceDef));
+    }
+    async _doList(operation, executionContext, ids_or_filter, options) {
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const filter = this.normalizeIdsOrFilter(ids_or_filter);
+        const contextualFilter = this.buildContextualFilter(executionContext, filter, options);
+        const where = this.buildWhere(contextualFilter);
+        const paginated = options?.paginated ?? false;
+        const listOptions = options?.listOptions;
+        const hasPagination = paginated || listOptions?.page !== undefined || listOptions?.limit !== undefined;
+        let page = 1;
+        let limit = 0;
+        let offset = 0;
+        let total = 0;
+        let totalPages = 1;
+        if (paginated || hasPagination) {
+            const countRow = await this.filterService.applyWhere(db.selectFrom(this.tableName).select(sql `count(*)`.as('count')), where).executeTakeFirst();
+            const countVal = countRow?.count;
+            total = typeof countVal === 'number' ? countVal : typeof countVal === 'string' ? Number(countVal) : 0;
+            page = Math.max(1, listOptions?.page || 1);
+            limit = Math.min(100, Math.max(1, listOptions?.limit || 20));
+            offset = (page - 1) * limit;
+            totalPages = limit > 0 ? Math.max(1, Math.ceil(total / limit)) : 1;
+        }
+        let qb = this.filterService.applyWhere(db.selectFrom(this.tableName).selectAll(), where);
+        if (this.plannedFieldNames.has('createdAt')) {
+            qb = qb.orderBy('createdAt', 'desc');
+        }
+        if (hasPagination) {
+            qb = qb.limit(limit).offset(offset);
+        }
+        const rows = await qb.execute();
+        const dataRows = rows.map((r) => this.sqlPlanner.transformFromSqlRead(r, inheritanceDef));
+        if (paginated) {
+            return {
+                data: dataRows,
+                pagination: { page, limit: limit || dataRows.length, total: total || dataRows.length, totalPages },
+            };
+        }
+        return dataRows;
+    }
+    async _doSearch(operation, executionContext, searchQuery, filter = {}, options) {
+        const db = await this.getDbOrTrx(options);
+        const inheritanceDef = this.resourceConfiguration?.inheritenceSchemaDefinition;
+        const searchConfig = this.findSearchOperationConfiguration();
+        if (!searchConfig) {
+            throw this.errorBuilder.buildError(ErrorType.NOT_FOUND, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_SEARCH_NOT_CONFIGURED,
+            });
+        }
+        const op = searchConfig;
+        if (!op.isSearchable) {
+            throw this.errorBuilder.buildError(ErrorType.BUSINESS_RULE, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_SEARCH_NOT_ENABLED,
+            });
+        }
+        const trimmed = String(searchQuery || '').trim();
+        const baseFilter = this.sanitizeRequestFilter(filter, searchConfig);
+        const page = Math.max(1, options?.searchOptions?.page || 1);
+        const maxLimit = op.maxPaginatedResultPerPageLimit || 50;
+        const limit = Math.min(maxLimit, Math.max(1, options?.searchOptions?.limit || 20));
+        const offset = (page - 1) * limit;
+        const searchFilter = trimmed
+            ? this.constructSearchQuery(trimmed, searchConfig, options?.searchOptions?.fieldsToSearch)
+            : {};
+        const combinedFilter = trimmed ? { $and: [baseFilter, searchFilter] } : baseFilter;
+        const contextualFilter = this.buildContextualFilter(executionContext, combinedFilter, options);
+        const where = this.buildWhere(contextualFilter);
+        const sortOptions = this.constructValidatedSortOptions(options?.searchOptions?.sort, searchConfig);
+        let qb = this.filterService.applyWhere(db.selectFrom(this.tableName).selectAll(), where);
+        if (sortOptions.length > 0) {
+            sortOptions.forEach((s) => {
+                qb = qb.orderBy(s.field, s.direction);
+            });
+        }
+        else if (this.plannedFieldNames.has('createdAt')) {
+            qb = qb.orderBy('createdAt', 'desc');
+        }
+        qb = qb.limit(limit).offset(offset);
+        const countRow = await this.filterService.applyWhere(db.selectFrom(this.tableName).select(sql `count(*)`.as('count')), where).executeTakeFirst();
+        const countVal = countRow?.count;
+        const total = typeof countVal === 'number' ? countVal : typeof countVal === 'string' ? Number(countVal) : 0;
+        const rows = await qb.execute();
+        const data = rows.map((r) => this.sqlPlanner.transformFromSqlRead(r, inheritanceDef));
+        return {
+            data,
+            pagination: { page, limit, total, totalPages: Math.ceil(total / limit) },
+        };
+    }
+    async _doCount(operation, executionContext, filter = {}, options) {
+        const db = await this.getDbOrTrx(options);
+        const contextualFilter = this.buildContextualFilter(executionContext, filter, options);
+        const where = this.buildWhere(contextualFilter);
+        const qb = this.filterService.applyWhere(db.selectFrom(this.tableName).select(sql `count(*)`.as('count')), where);
+        const row = await qb.executeTakeFirst();
+        const countVal = row?.count;
+        if (typeof countVal === 'number')
+            return { count: countVal };
+        if (typeof countVal === 'string')
+            return { count: Number(countVal) };
+        return { count: 0 };
+    }
+    // ===========================================================================
+    // DB client resolution
+    // ===========================================================================
+    async getDbOrTrx(options) {
+        const tx = this.getTransaction(options);
+        if (tx) {
+            return tx.nativeSession;
+        }
+        return await this.dbService.getDb();
+    }
+    // ===========================================================================
+    // Helpers
+    // ===========================================================================
+    normalizeIdsOrFilter(ids_or_filter) {
+        if (!ids_or_filter)
+            return {};
+        if (Array.isArray(ids_or_filter))
+            return { _id: { $in: ids_or_filter } };
+        if (typeof ids_or_filter === 'object' && ids_or_filter !== null && 'ids' in ids_or_filter) {
+            const ids = ids_or_filter.ids;
+            const filter = ids_or_filter.filter;
+            const base = Array.isArray(ids) ? { _id: { $in: ids } } : {};
+            return filter ? { $and: [base, filter] } : base;
+        }
+        return ids_or_filter;
+    }
+    /**
+     * Validate an ID using ResourceIdBackendService if available.
+     * For PostgreSQL, IDs should be valid UUIDs.
+     *
+     * @param id - The ID to validate
+     * @param executionContext - Execution context for error handling
+     * @throws Error if ID is invalid
+     */
+    validateId(id, executionContext) {
+        if (this.resourceIdService) {
+            const resourceType = String(this.resourceConfiguration.resourceIdentifier);
+            if (!this.resourceIdService.validateForResource(id, resourceType)) {
+                throw this.errorBuilder.buildError(ErrorType.VALIDATION, executionContext, {
+                    customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                    context: { message: `Invalid ID format for resource ${resourceType}: ${id}` },
+                });
+            }
+        }
+    }
+    buildBaseFilterFromIdOrFilter(id_or_filter, executionContext) {
+        let baseFilter = {};
+        if (!id_or_filter)
+            return { baseFilter };
+        if (typeof id_or_filter === 'string') {
+            this.validateId(id_or_filter, executionContext);
+            baseFilter = { _id: id_or_filter };
+        }
+        else if (typeof id_or_filter === 'object' && !Array.isArray(id_or_filter)) {
+            if ('id' in id_or_filter) {
+                const id = id_or_filter.id;
+                if (typeof id === 'string')
+                    this.validateId(id, executionContext);
+                baseFilter = { _id: id };
+                const extra = id_or_filter.filter;
+                if (extra && Object.keys(extra).length > 0) {
+                    baseFilter = { $and: [baseFilter, extra] };
+                }
+            }
+            else if ('id_or_ids' in id_or_filter) {
+                const ids = id_or_filter.id_or_ids;
+                if (typeof ids === 'string') {
+                    this.validateId(ids, executionContext);
+                    baseFilter = { _id: ids };
+                }
+                else if (Array.isArray(ids)) {
+                    ids.forEach((id) => this.validateId(id, executionContext));
+                    baseFilter = { _id: { $in: ids } };
+                }
+                const extra = id_or_filter.filter;
+                if (extra && Object.keys(extra).length > 0) {
+                    baseFilter = { $and: [baseFilter, extra] };
+                }
+            }
+            else {
+                baseFilter = id_or_filter;
+            }
+        }
+        else {
+            throw this.errorBuilder.buildError(ErrorType.VALIDATION, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.REPOSITORY_RESOURCE_OPERATION_FAILED,
+                context: { message: 'Invalid id_or_filter format' },
+            });
+        }
+        return { baseFilter };
+    }
+    buildContextualFilter(executionContext, baseFilter, options) {
+        const contextualFilter = { ...(baseFilter || {}) };
+        if (options?.excludeContextualFilter === true) {
+            return contextualFilter;
+        }
+        const blacklistedFields = new Set();
+        blacklistedFields.add(this.resourceConfiguration.resourceFieldIdentifier);
+        if (Array.isArray(options?.excludeContextualFilter)) {
+            options.excludeContextualFilter.forEach((f) => blacklistedFields.add(f));
+        }
+        const contextResourceIds = executionContext.getContextResourceIds();
+        contextResourceIds.forEach((resourceId, fieldIdentifier) => {
+            if (blacklistedFields.has(fieldIdentifier))
+                return;
+            const matchingPaths = this.resourceOperationHelper.findRequiredNestedFieldPathsFromZodSchema(this.resourceConfiguration.mainSchema, fieldIdentifier, executionContext, {
+                reason: 'context_filter',
+                resourceIdentifier: this.resourceConfiguration.resourceIdentifier,
+                message: `Execution context field '${fieldIdentifier}' is missing from schema for resource '${this.resourceConfiguration.resourceIdentifier}' during contextual filtering`,
+            });
+            matchingPaths.forEach((fullPath) => {
+                if (!this.resourceOperationHelper.hasNestedPath(contextualFilter, fullPath)) {
+                    this.resourceOperationHelper.setNestedValue(contextualFilter, fullPath, resourceId);
+                }
+            });
+        });
+        // Ensure organization scoping when available and not already set
+        const orgId = executionContext.initiatorIds?.organizationId;
+        if (orgId && this.plannedFieldNames.has('organizationId') && !blacklistedFields.has('organizationId')) {
+            const orgPaths = this.resourceOperationHelper.findNestedFieldPathsFromZodSchema(this.resourceConfiguration.mainSchema, 'organizationId');
+            orgPaths.forEach((fullPath) => {
+                if (!this.resourceOperationHelper.hasNestedPath(contextualFilter, fullPath)) {
+                    this.resourceOperationHelper.setNestedValue(contextualFilter, fullPath, orgId);
+                }
+            });
+        }
+        // Defense-in-depth: enforce userId = null for ANONYMOUS scope on isAnonymizable resources
+        if (executionContext.isAnonymousExecution() && this.resourceConfiguration.isAnonymizable) {
+            const userPaths = this.resourceOperationHelper.findNestedFieldPathsFromZodSchema(this.resourceConfiguration.mainSchema, 'userId');
+            userPaths.forEach(fullPath => {
+                this.resourceOperationHelper.setNestedValue(contextualFilter, fullPath, null);
+            });
+        }
+        this.applyFKRelationshipFilters(executionContext, contextualFilter, blacklistedFields);
+        return contextualFilter;
+    }
+    applyFKRelationshipFilters(executionContext, filter, blacklistedFields) {
+        const relationshipContexts = executionContext.relationshipContexts;
+        if (!relationshipContexts || relationshipContexts.length === 0)
+            return;
+        for (const relationshipContext of relationshipContexts) {
+            const { relationshipField, resourceId } = relationshipContext;
+            if (!relationshipField)
+                continue;
+            if (blacklistedFields.has(relationshipField))
+                continue;
+            const matchingPaths = this.resourceOperationHelper.findRequiredNestedFieldPathsFromZodSchema(this.resourceConfiguration.mainSchema, relationshipField, executionContext, {
+                reason: 'fk_filter',
+                resourceIdentifier: this.resourceConfiguration.resourceIdentifier,
+                message: `Relationship field '${relationshipField}' is missing from schema for resource '${this.resourceConfiguration.resourceIdentifier}' during FK-path filtering`,
+            });
+            matchingPaths.forEach((fullPath) => {
+                if (!this.resourceOperationHelper.hasNestedPath(filter, fullPath)) {
+                    this.resourceOperationHelper.setNestedValue(filter, fullPath, resourceId);
+                }
+            });
+        }
+    }
+    async resolveSingleId(executionContext, baseFilter, options) {
+        if (baseFilter && typeof baseFilter === 'object' && !Array.isArray(baseFilter) && '_id' in baseFilter) {
+            const idVal = baseFilter._id;
+            if (typeof idVal === 'string')
+                return idVal;
+            if (idVal && typeof idVal === 'object' && Array.isArray(idVal.$in) && idVal.$in.length > 0) {
+                return idVal.$in[0];
+            }
+        }
+        const contextualFilter = this.buildContextualFilter(executionContext, baseFilter, options);
+        const where = this.buildWhere(contextualFilter);
+        const db = await this.getDbOrTrx(options);
+        let qb = this.filterService.applyWhere(db.selectFrom(this.tableName).select(['_id']), where);
+        if (this.plannedFieldNames.has('createdAt')) {
+            qb = qb.orderBy('createdAt', 'desc');
+        }
+        const row = await qb.executeTakeFirst();
+        return row?._id ?? null;
+    }
+    findSearchOperationConfiguration() {
+        return Array.from(this.operationsMap.values()).find(operation => operation.operationIdentifier === CoreResourceOperation.SEARCH) ?? null;
+    }
+    constructSearchQuery(searchQuery, searchConfig, fieldsOverride) {
+        if (!searchQuery?.trim())
+            return {};
+        const op = searchConfig;
+        const allowed = Array.isArray(op.searchableFields)
+            ? op.searchableFields
+            : [];
+        const fields = Array.isArray(fieldsOverride) && fieldsOverride.length > 0
+            ? fieldsOverride.filter((f) => allowed.includes(f))
+            : allowed;
+        const orClauses = fields.map((f) => ({ [f]: { $contains: searchQuery, $options: 'i' } }));
+        return orClauses.length > 0 ? { $or: orClauses } : {};
+    }
+    sanitizeRequestFilter(filter, searchConfig) {
+        if (!filter || typeof filter !== 'object')
+            return {};
+        const { filterFields } = searchConfig;
+        if (!filterFields || Object.keys(filterFields).length === 0)
+            return filter;
+        const allowedKeys = Object.keys(filterFields);
+        const allowField = (field) => allowedKeys.includes(field) || allowedKeys.some((a) => field.startsWith(`${a}.`));
+        const sanitizeObject = (obj) => {
+            if (!obj || typeof obj !== 'object')
+                return obj;
+            const out = {};
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === '$and' || key === '$or') {
+                    if (Array.isArray(value)) {
+                        const arr = value.map((v) => sanitizeObject(v)).filter((v) => v && Object.keys(v).length > 0);
+                        if (arr.length > 0)
+                            out[key] = arr;
+                    }
+                    continue;
+                }
+                if (key === '$not') {
+                    const inner = sanitizeObject(value);
+                    if (inner && Object.keys(inner).length > 0)
+                        out[key] = inner;
+                    continue;
+                }
+                if (allowField(key))
+                    out[key] = value;
+            }
+            return out;
+        };
+        return sanitizeObject(filter);
+    }
+    constructValidatedSortOptions(requestedSort, searchConfig) {
+        const op = searchConfig;
+        const sortFields = Array.isArray(op.sortFields)
+            ? op.sortFields
+            : [];
+        const validated = [];
+        if (sortFields.length === 0)
+            return validated;
+        if (!requestedSort) {
+            const first = sortFields[0];
+            return first ? [{ field: first, direction: 'desc' }] : validated;
+        }
+        Object.entries(requestedSort).forEach(([field, dir]) => {
+            if (sortFields.includes(field) && (dir === 1 || dir === -1)) {
+                validated.push({ field, direction: dir === 1 ? 'asc' : 'desc' });
+            }
+        });
+        return validated;
+    }
+    addUserTrackingAndTimestamps(enrichedData, executionContext, operation) {
+        const out = { ...(enrichedData || {}) };
+        const userId = executionContext?.initiatorIds?.userId;
+        const now = new Date();
+        if (operation === CoreResourceOperation.CREATE) {
+            if (this.plannedFieldNames.has('createdAt') && !out.createdAt)
+                out.createdAt = now;
+            if (this.plannedFieldNames.has('updatedAt') && !out.updatedAt)
+                out.updatedAt = now;
+            if (userId && this.plannedFieldNames.has('createdByUserId') && !out.createdByUserId)
+                out.createdByUserId = userId;
+        }
+        if (operation === CoreResourceOperation.UPDATE) {
+            if (this.plannedFieldNames.has('updatedAt'))
+                out.updatedAt = now;
+            if (userId && this.plannedFieldNames.has('updatedByUserId') && !out.updatedByUserId)
+                out.updatedByUserId = userId;
+            if (userId && this.plannedFieldNames.has('lastUpdatedByUserId') && !out.lastUpdatedByUserId)
+                out.lastUpdatedByUserId = userId;
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=postgresql-resource-repository.backend.service.js.map