@owox/backend 0.0.0

package/dist/common/scheduler/services/runners/abstract-trigger-runner.service.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTriggerRunnerService = void 0;
+const time_based_trigger_entity_1 = require("../../shared/entities/time-based-trigger.entity");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+class AbstractTriggerRunnerService {
+    handler;
+    systemClock;
+    shutdownService;
+    logger = new common_1.Logger(this.constructor.name);
+    handlerName;
+    constructor(handler, systemClock, shutdownService) {
+        this.handler = handler;
+        this.systemClock = systemClock;
+        this.shutdownService = shutdownService;
+        this.handlerName = this.handler.constructor.name;
+    }
+    async runTriggers(triggers) {
+        if (triggers.length === 0) {
+            this.logger.debug(`[${this.handlerName}] No triggers found for processing`);
+            return;
+        }
+        this.logger.debug(`[${this.handlerName}] Processing ${triggers.length} triggers`);
+        await this.processTriggers(triggers);
+    }
+    async processTriggerSafely(trigger) {
+        const repository = this.handler.getTriggerRepository();
+        let processId = null;
+        if (this.shutdownService.isInShutdownMode()) {
+            const shutdownError = new Error(`Cannot process trigger ${trigger.id}: Application is shutting down`);
+            this.logger.warn(`[${this.handlerName}] ${shutdownError.message}`);
+            throw shutdownError;
+        }
+        try {
+            processId = this.shutdownService.registerActiveProcess(`${this.handlerName}-trigger-${trigger.id}`);
+            await this.updateTriggerStatus(trigger, time_based_trigger_entity_1.TriggerStatus.PROCESSING, repository);
+            await this.executeTrigger(trigger, repository);
+            this.logger.debug(`[${this.handlerName}] Successfully processed trigger: ${trigger.id}`);
+        }
+        catch (error) {
+            await this.handleTriggerError(error, trigger, repository);
+        }
+        finally {
+            if (processId) {
+                this.shutdownService.unregisterActiveProcess(processId);
+            }
+        }
+    }
+    async executeTrigger(trigger, repository) {
+        await this.handler.handleTrigger(trigger);
+        trigger.onSuccess(this.systemClock.now());
+        await repository.save(trigger);
+    }
+    async handleTriggerError(error, trigger, repository) {
+        if (this.isOptimisticLockError(error)) {
+            this.logger.debug(`[${this.handlerName}] Optimistic lock conflict for trigger ${trigger.id}. Skipping as likely processed by another instance.`);
+            return;
+        }
+        this.logger.error(`[${this.handlerName}] Failed to process trigger ${trigger.id}:`, error);
+        try {
+            await this.markTriggerAsError(trigger, repository);
+        }
+        catch (secondaryError) {
+            this.logger.error(`[${this.handlerName}] Failed to mark trigger ${trigger.id} as error:`, secondaryError);
+        }
+    }
+    async updateTriggerStatus(trigger, status, repository) {
+        trigger.status = status;
+        await repository.save(trigger);
+    }
+    async markTriggerAsError(trigger, repository) {
+        trigger.onError(this.systemClock.now());
+        await repository.save(trigger);
+    }
+    isOptimisticLockError(error) {
+        return (error instanceof typeorm_1.QueryFailedError &&
+            (error.message.includes('version') || error.message.includes('optimistic lock')));
+    }
+}
+exports.AbstractTriggerRunnerService = AbstractTriggerRunnerService;
+//# sourceMappingURL=abstract-trigger-runner.service.js.map

package/dist/common/scheduler/services/runners/direct-trigger-runner.service.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectTriggerRunnerService = void 0;
+const abstract_trigger_runner_service_1 = require("./abstract-trigger-runner.service");
+class DirectTriggerRunnerService extends abstract_trigger_runner_service_1.AbstractTriggerRunnerService {
+    constructor(handler, systemClock, shutdownService) {
+        super(handler, systemClock, shutdownService);
+    }
+    async processTriggers(triggers) {
+        await Promise.all(triggers.map(trigger => this.processTriggerSafely(trigger)));
+    }
+}
+exports.DirectTriggerRunnerService = DirectTriggerRunnerService;
+//# sourceMappingURL=direct-trigger-runner.service.js.map

package/dist/common/scheduler/services/runners/pubsub-trigger-runner.service.js

@@ -0,0 +1,145 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubsubTriggerRunnerService = void 0;
+const pubsub_1 = require("@google-cloud/pubsub");
+const common_1 = require("@nestjs/common");
+const system_time_service_1 = require("../system-time.service");
+const abstract_trigger_runner_service_1 = require("./abstract-trigger-runner.service");
+const graceful_shutdown_service_1 = require("../graceful-shutdown.service");
+let PubsubTriggerRunnerService = class PubsubTriggerRunnerService extends abstract_trigger_runner_service_1.AbstractTriggerRunnerService {
+    googleCloudProject;
+    pubSubClient;
+    topicName;
+    subscriptionName;
+    constructor(handler, systemClock, googleCloudProject, shutdownService) {
+        super(handler, systemClock, shutdownService);
+        this.googleCloudProject = googleCloudProject;
+        this.topicName = this.generateTopicName();
+        this.subscriptionName = this.generateSubscriptionName();
+        this.pubSubClient = this.createPubSubClient();
+    }
+    async initialize() {
+        await this.setupPubSubListener();
+    }
+    generateTopicName() {
+        return `owox-data-marts-${this.handlerName.toLowerCase()}-triggers`;
+    }
+    generateSubscriptionName() {
+        return `${this.topicName}-subscription`;
+    }
+    createPubSubClient() {
+        return new pubsub_1.PubSub({ projectId: this.googleCloudProject });
+    }
+    async setupPubSubListener() {
+        try {
+            await this.ensureTopicExists();
+            await this.ensureSubscriptionExists();
+            this.setupMessageHandlers();
+            this.logger.log('PubSub listener setup complete');
+        }
+        catch (error) {
+            this.logger.error('Error setting up PubSub listener:', error);
+            throw error;
+        }
+    }
+    async ensureTopicExists() {
+        const [topicExists] = await this.pubSubClient.topic(this.topicName).exists();
+        if (!topicExists) {
+            await this.pubSubClient.createTopic(this.topicName);
+            this.logger.log(`Created topic: ${this.topicName}`);
+        }
+    }
+    async ensureSubscriptionExists() {
+        const [subscriptionExists] = await this.pubSubClient
+            .topic(this.topicName)
+            .subscription(this.subscriptionName)
+            .exists();
+        if (!subscriptionExists) {
+            await this.pubSubClient.topic(this.topicName).createSubscription(this.subscriptionName);
+            this.logger.log(`Created subscription: ${this.subscriptionName}`);
+        }
+    }
+    setupMessageHandlers() {
+        const subscription = this.pubSubClient
+            .topic(this.topicName)
+            .subscription(this.subscriptionName);
+        subscription.on('message', this.handlePubSubMessage.bind(this));
+        subscription.on('error', this.handlePubSubError.bind(this));
+    }
+    async handlePubSubMessage(message) {
+        try {
+            const messageData = message.data.toString();
+            const payload = JSON.parse(messageData);
+            const triggerId = payload.id;
+            const messageVersion = payload.version;
+            this.logger.log(`Received message with trigger ID: ${triggerId}, version: ${messageVersion}`);
+            const trigger = await this.findTriggerById(triggerId);
+            if (!trigger) {
+                this.logger.error(`Trigger with ID ${triggerId} not found`);
+            }
+            else if (trigger.version !== messageVersion) {
+                this.logger.warn(`Skipping outdated message for trigger ${triggerId}: message version ${messageVersion}, current version ${trigger.version}`);
+            }
+            else {
+                await this.processTriggerSafely(trigger);
+            }
+        }
+        catch (error) {
+            this.logger.error('Error processing PubSub message:', error);
+        }
+        finally {
+            message.ack();
+        }
+    }
+    async findTriggerById(triggerId) {
+        const options = { where: { id: triggerId } };
+        return this.handler.getTriggerRepository().findOne(options);
+    }
+    handlePubSubError(error) {
+        this.logger.error('PubSub subscription error:', error);
+    }
+    async processTriggers(triggers) {
+        try {
+            const publishPromises = triggers.map(trigger => this.publishTriggerToPubSub(trigger));
+            await Promise.all(publishPromises);
+            this.logger.debug(`Successfully published ${triggers.length} triggers to PubSub`);
+        }
+        catch (error) {
+            this.logger.error('Error publishing triggers to PubSub:', error);
+            throw error;
+        }
+    }
+    async publishTriggerToPubSub(trigger) {
+        const payload = {
+            id: trigger.id,
+            version: trigger.version,
+        };
+        const dataBuffer = Buffer.from(JSON.stringify(payload));
+        try {
+            const messageId = await this.pubSubClient
+                .topic(this.topicName)
+                .publishMessage({ data: dataBuffer });
+            this.logger.debug(`Published message ${messageId} for trigger ${trigger.id} (version ${trigger.version})`);
+            return messageId;
+        }
+        catch (error) {
+            this.logger.error(`Error publishing trigger ${trigger.id}:`, error);
+            throw error;
+        }
+    }
+};
+exports.PubsubTriggerRunnerService = PubsubTriggerRunnerService;
+exports.PubsubTriggerRunnerService = PubsubTriggerRunnerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, system_time_service_1.SystemTimeService, String, graceful_shutdown_service_1.GracefulShutdownService])
+], PubsubTriggerRunnerService);
+//# sourceMappingURL=pubsub-trigger-runner.service.js.map

package/dist/common/scheduler/services/runners/trigger-runner.factory.js

@@ -0,0 +1,87 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var TriggerRunnerFactory_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerRunnerFactory = exports.TriggerRunnerType = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const direct_trigger_runner_service_1 = require("./direct-trigger-runner.service");
+const pubsub_trigger_runner_service_1 = require("./pubsub-trigger-runner.service");
+const graceful_shutdown_service_1 = require("../graceful-shutdown.service");
+var TriggerRunnerType;
+(function (TriggerRunnerType) {
+    TriggerRunnerType["DIRECT"] = "direct";
+    TriggerRunnerType["PUBSUB"] = "pubsub";
+})(TriggerRunnerType || (exports.TriggerRunnerType = TriggerRunnerType = {}));
+let TriggerRunnerFactory = TriggerRunnerFactory_1 = class TriggerRunnerFactory {
+    configService;
+    shutdownService;
+    logger = new common_1.Logger(TriggerRunnerFactory_1.name);
+    runnerTypes = new Map();
+    constructor(configService, shutdownService) {
+        this.configService = configService;
+        this.shutdownService = shutdownService;
+        this.registerDefaultRunnerTypes();
+    }
+    registerDefaultRunnerTypes() {
+        this.registerRunnerType(TriggerRunnerType.DIRECT, {
+            type: direct_trigger_runner_service_1.DirectTriggerRunnerService,
+            configFactory: () => ({}),
+        });
+        this.registerRunnerType(TriggerRunnerType.PUBSUB, {
+            type: pubsub_trigger_runner_service_1.PubsubTriggerRunnerService,
+            configFactory: (configService) => ({
+                projectId: configService.get('SCHEDULER_PUBSUB_PROJECT_ID'),
+            }),
+        });
+    }
+    registerRunnerType(type, options) {
+        this.runnerTypes.set(type, options);
+        this.logger.log(`Registered runner type: ${type}`);
+    }
+    stringToRunnerType(typeString) {
+        const enumValues = Object.values(TriggerRunnerType);
+        if (enumValues.includes(typeString)) {
+            return typeString;
+        }
+        this.logger.warn(`Invalid runner type string: ${typeString}, using default`);
+        return TriggerRunnerType.DIRECT;
+    }
+    async createRunner(triggerHandler, systemTimeService) {
+        const runnerTypeString = this.configService.get('SCHEDULER_TRIGGER_RUNNER_TYPE', TriggerRunnerType.DIRECT);
+        const runnerType = this.stringToRunnerType(runnerTypeString);
+        const runnerConfig = this.runnerTypes.get(runnerType);
+        if (!runnerConfig) {
+            this.logger.warn(`Unknown runner type: ${runnerType}, falling back to direct runner`);
+            return new direct_trigger_runner_service_1.DirectTriggerRunnerService(triggerHandler, systemTimeService, this.shutdownService);
+        }
+        const { type: RunnerClass, configFactory } = runnerConfig;
+        const config = configFactory(this.configService);
+        const runner = await this.createRunnerInstance(RunnerClass, triggerHandler, systemTimeService, config, this.shutdownService);
+        this.logger.log(`Created ${runnerType} trigger runner`);
+        return runner;
+    }
+    async createRunnerInstance(RunnerClass, triggerHandler, systemTimeService, config, shutdownService) {
+        if (RunnerClass === pubsub_trigger_runner_service_1.PubsubTriggerRunnerService) {
+            const pubSubRunner = new pubsub_trigger_runner_service_1.PubsubTriggerRunnerService(triggerHandler, systemTimeService, config.projectId, shutdownService);
+            await pubSubRunner.initialize();
+            return pubSubRunner;
+        }
+        return new direct_trigger_runner_service_1.DirectTriggerRunnerService(triggerHandler, systemTimeService, shutdownService);
+    }
+};
+exports.TriggerRunnerFactory = TriggerRunnerFactory;
+exports.TriggerRunnerFactory = TriggerRunnerFactory = TriggerRunnerFactory_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService,
+        graceful_shutdown_service_1.GracefulShutdownService])
+], TriggerRunnerFactory);
+//# sourceMappingURL=trigger-runner.factory.js.map

package/dist/common/scheduler/services/runners/trigger-runner.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=trigger-runner.interface.js.map

package/dist/common/scheduler/services/system-time.service.js

@@ -0,0 +1,20 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemTimeService = void 0;
+const common_1 = require("@nestjs/common");
+let SystemTimeService = class SystemTimeService {
+    now() {
+        return new Date();
+    }
+};
+exports.SystemTimeService = SystemTimeService;
+exports.SystemTimeService = SystemTimeService = __decorate([
+    (0, common_1.Injectable)()
+], SystemTimeService);
+//# sourceMappingURL=system-time.service.js.map

package/dist/common/scheduler/shared/entities/scheduled-trigger.entity.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledTrigger = void 0;
+const time_based_trigger_entity_1 = require("./time-based-trigger.entity");
+const typeorm_1 = require("typeorm");
+const cron_1 = require("cron");
+class ScheduledTrigger extends time_based_trigger_entity_1.TimeBasedTrigger {
+    cronExpression;
+    timeZone;
+    onSuccess(lastRunTimestamp) {
+        this.lastRunTimestamp = lastRunTimestamp;
+        this.scheduleNextRun(lastRunTimestamp);
+    }
+    onError(lastRunTimestamp) {
+        this.lastRunTimestamp = lastRunTimestamp;
+        this.scheduleNextRun(lastRunTimestamp);
+    }
+    scheduleNextRun(startFrom) {
+        const cronTime = new cron_1.CronTime(this.cronExpression, this.timeZone);
+        const nextRunTimestamp = cronTime.getNextDateFrom(startFrom).toJSDate();
+        if (nextRunTimestamp <= startFrom) {
+            throw new Error('Next run timestamp is in the past');
+        }
+        this.nextRunTimestamp = nextRunTimestamp;
+        this.isActive = true;
+        this.status = time_based_trigger_entity_1.TriggerStatus.IDLE;
+    }
+}
+exports.ScheduledTrigger = ScheduledTrigger;
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ScheduledTrigger.prototype, "cronExpression", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ScheduledTrigger.prototype, "timeZone", void 0);
+//# sourceMappingURL=scheduled-trigger.entity.js.map

package/dist/common/scheduler/shared/entities/time-based-trigger.entity.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeBasedTrigger = exports.TriggerStatus = void 0;
+const typeorm_1 = require("typeorm");
+var TriggerStatus;
+(function (TriggerStatus) {
+    TriggerStatus["IDLE"] = "IDLE";
+    TriggerStatus["READY"] = "READY";
+    TriggerStatus["PROCESSING"] = "PROCESSING";
+    TriggerStatus["SUCCESS"] = "SUCCESS";
+    TriggerStatus["ERROR"] = "ERROR";
+})(TriggerStatus || (exports.TriggerStatus = TriggerStatus = {}));
+class TimeBasedTrigger {
+    id;
+    nextRunTimestamp;
+    lastRunTimestamp;
+    isActive;
+    version;
+    status;
+    onSuccess(lastRunTimestamp) {
+        this.lastRunTimestamp = lastRunTimestamp;
+        this.status = TriggerStatus.SUCCESS;
+        this.discardNextRun();
+    }
+    onError(lastRunTimestamp) {
+        this.lastRunTimestamp = lastRunTimestamp;
+        this.status = TriggerStatus.ERROR;
+    }
+    discardNextRun() {
+        this.nextRunTimestamp = null;
+        this.isActive = false;
+    }
+}
+exports.TimeBasedTrigger = TimeBasedTrigger;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], TimeBasedTrigger.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'datetime', nullable: true }),
+    __metadata("design:type", Object)
+], TimeBasedTrigger.prototype, "nextRunTimestamp", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'datetime', nullable: true }),
+    __metadata("design:type", Object)
+], TimeBasedTrigger.prototype, "lastRunTimestamp", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Boolean)
+], TimeBasedTrigger.prototype, "isActive", void 0);
+__decorate([
+    (0, typeorm_1.VersionColumn)(),
+    __metadata("design:type", Number)
+], TimeBasedTrigger.prototype, "version", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        enum: TriggerStatus,
+        default: TriggerStatus.IDLE,
+    }),
+    __metadata("design:type", String)
+], TimeBasedTrigger.prototype, "status", void 0);
+//# sourceMappingURL=time-based-trigger.entity.js.map

package/dist/common/scheduler/shared/scheduler.facade.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEDULER_FACADE = void 0;
+exports.SCHEDULER_FACADE = 'SCHEDULER_FACADE';
+//# sourceMappingURL=scheduler.facade.js.map

package/dist/common/scheduler/shared/time-based-trigger-handler.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=time-based-trigger-handler.interface.js.map

package/dist/config/database.config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatabaseConfig = getDatabaseConfig;
+var DbType;
+(function (DbType) {
+    DbType["sqlite"] = "sqlite";
+    DbType["mysql"] = "mysql";
+})(DbType || (DbType = {}));
+function getDatabaseConfig(config) {
+    const type = config.get('DB_TYPE', DbType.sqlite);
+    const dbConfigs = {
+        [DbType.sqlite]: {
+            type: DbType.sqlite,
+            database: config.get('DB_NAME', 'var/sqlite/backend.db'),
+            entities: [__dirname + '/../**/*.entity{.ts,.js}'],
+            synchronize: true,
+        },
+        [DbType.mysql]: {
+            type: DbType.mysql,
+            host: config.get('DB_HOST'),
+            port: config.get('DB_PORT'),
+            username: config.get('DB_USERNAME'),
+            password: config.get('DB_PASSWORD'),
+            database: config.get('DB_DATABASE'),
+            entities: [__dirname + '/../**/*.entity{.ts,.js}'],
+            synchronize: true,
+        },
+    };
+    return dbConfigs[type];
+}
+//# sourceMappingURL=database.config.js.map

package/dist/config/express-static.config.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStaticAssets = setupStaticAssets;
+const common_1 = require("@nestjs/common");
+const fs_1 = require("fs");
+const path_1 = require("path");
+function getWebDistPath() {
+    const logger = new common_1.Logger('StaticAssets');
+    const publishedPath = (0, path_1.join)(__dirname, '..', 'public');
+    const devPath = (0, path_1.join)(__dirname, '..', '..', '..', 'web', 'dist');
+    if ((0, fs_1.existsSync)(publishedPath)) {
+        logger.log(`Using published static assets: ${publishedPath}`);
+        return publishedPath;
+    }
+    if ((0, fs_1.existsSync)(devPath)) {
+        logger.log(`Using development static assets: ${devPath}`);
+        return devPath;
+    }
+    throw new Error(`Static assets not found. Checked:\n  - ${publishedPath}\n  - ${devPath}`);
+}
+function setupStaticAssets(app, pathPrefix) {
+    const distPath = getWebDistPath();
+    app.useStaticAssets(distPath);
+    app.use((req, res, next) => {
+        if (req.path.startsWith(`/${pathPrefix}`)) {
+            next();
+        }
+        else {
+            res.sendFile((0, path_1.join)(distPath, 'index.html'));
+        }
+    });
+}
+//# sourceMappingURL=express-static.config.js.map

package/dist/config/global-pipes.config.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGlobalPipes = setupGlobalPipes;
+const common_1 = require("@nestjs/common");
+function setupGlobalPipes(app) {
+    app.useGlobalPipes(new common_1.ValidationPipe({
+        whitelist: true,
+        forbidNonWhitelisted: true,
+        transform: true,
+    }));
+}
+//# sourceMappingURL=global-pipes.config.js.map

package/dist/config/swagger.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSwagger = setupSwagger;
+const swagger_1 = require("@nestjs/swagger");
+function setupSwagger(app, path) {
+    const config = new swagger_1.DocumentBuilder()
+        .setTitle('Backend API')
+        .setDescription('REST API used by frontend clients and service integrations.')
+        .setVersion('1.0')
+        .build();
+    const document = swagger_1.SwaggerModule.createDocument(app, config);
+    swagger_1.SwaggerModule.setup(path, app, document, {
+        useGlobalPrefix: false,
+    });
+}
+//# sourceMappingURL=swagger.config.js.map