@x-fiber-sys/dev-tool 0.1.0

package/dist/_cjs/templates/ioc.template.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IocTemplate = void 0;
+const morphix_1 = require("@terra-versity/morphix");
+const ts_morph_1 = require("ts-morph");
+const common_1 = require("../common");
+class IocTemplate {
+    constructor(path, concept) {
+        this._imports = new morphix_1.ImportsSculptor();
+        this._variables = new morphix_1.VariablesSculptor();
+        this._path = path;
+        this._concept = concept;
+    }
+    generate() {
+        const { libraries } = this._concept;
+        let source = new ts_morph_1.Project().createSourceFile(this._path, '', { overwrite: true });
+        const symbols = {
+            Registry: 'Registry',
+            Config: 'Config',
+            Logger: 'Logger',
+            Context: 'Context',
+            Tracer: 'Tracer',
+        };
+        const imports = [
+            {
+                module: common_1.LibrariesKindMapping.be_common,
+                namedImports: common_1.CommonKindMapping.create_symbols,
+            },
+            {
+                module: common_1.LibrariesKindMapping.reflection,
+                namedImports: [common_1.ReflectionKindMapping.locator, common_1.ReflectionKindMapping.registry],
+            },
+            {
+                module: common_1.LibrariesKindMapping.be_config,
+                namedImports: common_1.ConfigKindMapping.config,
+            },
+            {
+                module: common_1.LibrariesKindMapping.context,
+                namedImports: common_1.ContextKindMapping.context,
+            },
+            {
+                module: common_1.LibrariesKindMapping.logger,
+                namedImports: common_1.LoggerKindMapping.logger,
+            },
+            {
+                module: common_1.LibrariesKindMapping.tracer,
+                namedImports: common_1.TracerKindMapping.tracer,
+            },
+        ];
+        if (libraries.postgres) {
+            imports.push({ module: common_1.LibrariesKindMapping.sql, namedImports: common_1.SqlKindMapping.postgres });
+            symbols['Postgres'] = 'Postgres';
+        }
+        if (libraries.slack) {
+            imports.push({ module: common_1.LibrariesKindMapping.slack, namedImports: common_1.SlackKindMapping.slack });
+            symbols['Slack'] = 'Slack';
+        }
+        if (libraries.httpServer) {
+            imports.push({
+                module: common_1.LibrariesKindMapping.http_server,
+                namedImports: common_1.HttpServerKindMapping.http_server,
+            });
+            symbols['HttpServer'] = 'HttpServer';
+        }
+        if (libraries.scrambler) {
+            imports.push({
+                module: common_1.LibrariesKindMapping.scrambler,
+                namedImports: common_1.ScramblerKindMapping.scrambler,
+            });
+            symbols['Scrambler'] = 'Scrambler';
+        }
+        source = this._imports.addModule(source, imports);
+        source = this._variables.addVariable(source, {
+            name: common_1.SYMBOL_NAME,
+            value: (writer) => {
+                writer.write('createSymbols(');
+                for (const [_, symbol] of Object.entries(symbols)) {
+                    writer.writeLine(`'${symbol}',`);
+                }
+                writer.write(')');
+            },
+        });
+        source = this._variables.addStatement(source, (writer) => {
+            writer.blankLine();
+            writer.write('locator.bindings({');
+            for (const [name, symbol] of Object.entries(symbols)) {
+                writer.writeLine(`[${common_1.SYMBOL_NAME}.${name}]: ${symbol},`);
+            }
+            writer.write('})');
+            writer.blankLine();
+        });
+        source = this._imports.addModule(source, { namedImports: 'Initiator', module: './initiator' });
+        source = this._variables.addStatement(source, (writer) => {
+            writer.writeLine(`locator.bindings({ [${common_1.SYMBOL_NAME}.Initiator]: 'Initiator' })`);
+        });
+        source = this._variables.addVariable(source, {
+            name: 'container',
+            value: (writer) => {
+                writer.blankLine();
+                writer.writeLine('locator.container');
+            },
+            isExportable: true,
+        });
+        source.saveSync();
+    }
+}
+exports.IocTemplate = IocTemplate;

package/dist/_cjs/templates/module.template.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleTemplate = void 0;
+const morphix_1 = require("@terra-versity/morphix");
+const ts_morph_1 = require("ts-morph");
+const common_1 = require("../common");
+const utils_1 = require("../utils");
+class ModuleTemplate {
+    constructor() {
+        this._imports = new morphix_1.ImportsSculptor();
+        this._class = new morphix_1.ClassSculptor();
+    }
+    content(ref, documents) {
+        let source = new ts_morph_1.Project().createSourceFile('./index.ts', '', { overwrite: true });
+        const imports = [
+            { module: common_1.LibrariesKindMapping.reflection, namedImports: common_1.ReflectionKindMapping.module },
+        ];
+        const transportImport = `${ref.class}${common_1.DocumentClassMapping.transport}`;
+        const controllerImport = `${ref.class}${common_1.DocumentClassMapping.controller}`;
+        const pgEntityImport = `${ref.class}${common_1.DocumentClassMapping.pg_entity}`;
+        const pgRepositoryImport = `${ref.class}${common_1.DocumentClassMapping.pg_repository}`;
+        const tmEntityImport = `${ref.class}${common_1.DocumentClassMapping.tm_entity}`;
+        const tmRepositoryImport = `${ref.class}${common_1.DocumentClassMapping.tm_repository}`;
+        const chEntityImport = `${ref.class}${common_1.DocumentClassMapping.ch_entity}`;
+        const chRepositoryImport = `${ref.class}${common_1.DocumentClassMapping.ch_repository}`;
+        if (documents.transport) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.transport}`,
+                namedImports: transportImport,
+            });
+        }
+        if (documents.controller) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.controller}`,
+                namedImports: controllerImport,
+            });
+        }
+        if (documents.pgEntity) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.pg_entity}`,
+                namedImports: pgEntityImport,
+            });
+        }
+        if (documents.pgRepository) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.pg_repository}`,
+                namedImports: pgRepositoryImport,
+            });
+        }
+        if (documents.tmEntity) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.tm_entity}`,
+                namedImports: tmEntityImport,
+            });
+        }
+        if (documents.tmRepository) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.tm_repository}`,
+                namedImports: tmRepositoryImport,
+            });
+        }
+        if (documents.chEntity) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.ch_entity}`,
+                namedImports: chEntityImport,
+            });
+        }
+        if (documents.chRepository) {
+            imports.push({
+                module: `./${ref.domain}.${common_1.DocumentKindMapping.ch_repository}`,
+                namedImports: chRepositoryImport,
+            });
+        }
+        imports.push({
+            module: (0, utils_1.getTypeAlias)(ref.service, common_1.TypingsKindMapping.service),
+            namedImports: common_1.ServiceTypingsKindMapping.domains,
+            isTypings: true,
+        });
+        source = this._imports.addModule(source, imports);
+        source = this._class.addClass(source, {
+            name: `${ref.class}${common_1.DocumentClassMapping.module}`,
+            options: { isExportable: true },
+            constructor: {},
+            decorators: {
+                name: common_1.ReflectionKindMapping.module,
+                typeArguments: [common_1.ServiceTypingsKindMapping.domains],
+                arguments: (writer) => {
+                    writer.writeLine(`'${ref.domain}', {`);
+                    if (documents.transport) {
+                        writer.writeLine(`${common_1.DocumentKindMapping.transport}: ${transportImport},`);
+                    }
+                    if (documents.controller) {
+                        writer.writeLine(`${common_1.DocumentKindMapping.controller}: ${controllerImport},`);
+                    }
+                    if (documents.pgEntity || documents.pgRepository) {
+                        writer.writeLine(`${common_1.ModuleBlockMapping.postgres}: {`);
+                        if (documents.pgEntity) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.entity}: ${pgEntityImport},`);
+                        }
+                        if (documents.pgRepository) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.repository}: ${pgRepositoryImport},`);
+                        }
+                        writer.writeLine(`},`);
+                    }
+                    if (documents.tmEntity || documents.tmRepository) {
+                        writer.writeLine(`${common_1.ModuleBlockMapping.timescale}: {`);
+                        if (documents.tmEntity) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.entity}: ${tmEntityImport},`);
+                        }
+                        if (documents.tmRepository) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.repository}: ${tmRepositoryImport},`);
+                        }
+                        writer.writeLine(`},`);
+                    }
+                    if (documents.chEntity || documents.chRepository) {
+                        writer.writeLine(`${common_1.ModuleBlockMapping.timescale}: {`);
+                        if (documents.chEntity) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.entity}: ${chEntityImport},`);
+                        }
+                        if (documents.chRepository) {
+                            writer.writeLine(`${common_1.ModuleBlockMapping.repository}: ${chRepositoryImport},`);
+                        }
+                        writer.writeLine(`},`);
+                    }
+                    writer.writeLine(`},`);
+                },
+            },
+        });
+        return source.getText();
+    }
+}
+exports.ModuleTemplate = ModuleTemplate;

package/dist/_cjs/templates/pg-repository.template.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresRepositoryTemplate = void 0;
+const morphix_1 = require("@terra-versity/morphix");
+const ts_morph_1 = require("ts-morph");
+const common_1 = require("../common");
+class PostgresRepositoryTemplate {
+    constructor() {
+        this._imports = new morphix_1.ImportsSculptor();
+        this._class = new morphix_1.ClassSculptor();
+    }
+    content(concept) {
+        let source = new ts_morph_1.Project().createSourceFile('./index.ts', '', { overwrite: true });
+        const imports = [
+            {
+                module: common_1.LibrariesKindMapping.reflection,
+                namedImports: [
+                    common_1.ReflectionKindMapping.bind,
+                    common_1.ReflectionKindMapping.transport,
+                    common_1.ReflectionKindMapping.extract,
+                ],
+            },
+        ];
+        source = this._imports.addModule(source, imports);
+        let constructor = undefined;
+        constructor = {
+            parameters: [
+                {
+                    name: common_1.SymbolsAliasMapping.logger,
+                    isReadonly: true,
+                    scope: ts_morph_1.Scope.Private,
+                    decorators: [
+                        {
+                            name: common_1.ReflectionKindMapping.extract,
+                            arguments: (writer) => {
+                                writer.writeLine(`${common_1.SYMBOL_NAME}.${common_1.SymbolsKindMapping.logger}`);
+                            },
+                        },
+                    ],
+                    type: (writer) => writer.writeLine(common_1.LoggerKindMapping.logger),
+                },
+                {
+                    name: common_1.SymbolsAliasMapping.postgres,
+                    isReadonly: true,
+                    scope: ts_morph_1.Scope.Private,
+                    decorators: [
+                        {
+                            name: common_1.ReflectionKindMapping.extract,
+                            arguments: (writer) => {
+                                writer.writeLine(`${common_1.SYMBOL_NAME}.${common_1.SymbolsKindMapping.postgres}`);
+                            },
+                        },
+                    ],
+                    type: (writer) => writer.writeLine(common_1.SqlKindMapping.postgres),
+                },
+            ],
+        };
+        const methods = [];
+        if (concept.actions.createOne && concept.actions.createOne.modules.postresRepository) {
+            methods.push(this._publicCreateOne(concept.ref));
+            methods.push(this._privateCreateOne(concept.ref, concept.item));
+        }
+        if (concept.actions.updateById && concept.actions.updateById.modules.postresRepository) {
+            methods.push(this._publicUpdateById(concept.ref));
+            methods.push(this._privateUpdateById(concept.ref, concept.item));
+        }
+        if (concept.actions.patchById && concept.actions.patchById.modules.postresRepository) {
+            methods.push(this._publicPatchById(concept.ref));
+            methods.push(this._privatePatchById(concept.ref, concept.item));
+        }
+        const withSoftDelete = concept.actions.softDeleteById && concept.actions.softDeleteById.modules.postresRepository;
+        const withRestore = concept.actions.restoreById && concept.actions.restoreById.modules.postresRepository;
+        if (withSoftDelete || withRestore) {
+            methods.push(this._publicDeleteModifyById(concept.ref));
+            methods.push(this._privateDeleteModifyById(concept.ref, concept.item));
+        }
+        const withArchive = concept.actions.archiveById && concept.actions.archiveById.modules.postresRepository;
+        const withUnarchive = concept.actions.unarchiveById && concept.actions.unarchiveById.modules.postresRepository;
+        if (withArchive || withUnarchive) {
+            methods.push(this._publicArchiveModifyById(concept.ref));
+            methods.push(this._privateArchiveModifyById(concept.ref, concept.item));
+        }
+        source = this._class.addClass(source, {
+            name: `${concept.ref.class}${common_1.DocumentClassMapping.pg_repository}`,
+            options: { isExportable: true },
+            decorators: { name: common_1.ReflectionKindMapping.bind, arguments: () => void 0 },
+            constructor,
+            methods,
+        });
+        return source.getText();
+    }
+    _publicCreateOne(ref) {
+        return {
+            name: common_1.ActionKindMapping.create_one,
+            isAsync: true,
+            scope: ts_morph_1.Scope.Public,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`return this._${common_1.ActionKindMapping.create_one}({ ref, trx }).execute()`);
+            },
+        };
+    }
+    _privateCreateOne(ref, item) {
+        return {
+            name: `_${common_1.ActionKindMapping.create_one}`,
+            isAsync: false,
+            scope: ts_morph_1.Scope.Private,
+            parameters: [
+                {
+                    name: 'row',
+                    type: (writer) => writer.writeLine(`Created${ref.class}`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine('const now = DateTime.now().toJSDate()');
+                writer.blankLine();
+                writer.writeLine(`return this.${common_1.SymbolsAliasMapping.postgres}.${common_1.SqlMethodKindMapping.repository}.${common_1.SqlMethodKindMapping.insert_row}(`);
+                writer.writeLine(`'${ref.entity}',`);
+                writer.writeLine('{');
+                for (const [name, { generator }] of Object.entries(item)) {
+                    if (generator.isTimestampGenerate) {
+                        writer.writeLine(`${name}: now,`);
+                        continue;
+                    }
+                    if (generator.isNullGenerate) {
+                        writer.writeLine(`${name}: null,`);
+                        continue;
+                    }
+                    writer.writeLine(`${name}: row.${name},`);
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine('trx,');
+                writer.writeLine(`returning: ['id'],`);
+                writer.writeLine('},');
+                writer.writeLine(')');
+            },
+        };
+    }
+    _publicUpdateById(ref) {
+        return {
+            name: common_1.ActionKindMapping.update_by_id,
+            isAsync: true,
+            scope: ts_morph_1.Scope.Public,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'fields',
+                    type: (writer) => writer.writeLine(`${ref.class}Updated`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`return this._${common_1.ActionKindMapping.update_by_id}({ ref, fields, trx }).execute()`);
+            },
+        };
+    }
+    _privateUpdateById(ref, item) {
+        return {
+            name: `_${common_1.ActionKindMapping.update_by_id}`,
+            isAsync: false,
+            scope: ts_morph_1.Scope.Private,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'fields',
+                    type: (writer) => writer.writeLine(`${ref.class}Updated`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine('const now = DateTime.now().toJSDate()');
+                writer.blankLine();
+                writer.writeLine(`return this.${common_1.SymbolsAliasMapping.postgres}.${common_1.SqlMethodKindMapping.repository}.${common_1.SqlMethodKindMapping.update_row}(`);
+                writer.writeLine(`'${ref.entity}',`);
+                writer.writeLine('{');
+                writer.writeLine(`${ref.item}_id: fields.${ref.item}_id,`);
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition) {
+                        writer.writeLine(`${generator.sqlAlias}: fields.${generator.partition.key},`);
+                    }
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition || !generator.isUpdated) {
+                        continue;
+                    }
+                    writer.writeLine(`${generator.sqlAlias}: fields.${generator.sqlAlias},`);
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine('trx,');
+                writer.writeLine(`returning: ['id'],`);
+                writer.writeLine(`strictness: 'weak',`);
+                writer.writeLine('},');
+                writer.writeLine(')');
+            },
+        };
+    }
+    _publicPatchById(ref) {
+        return {
+            name: common_1.ActionKindMapping.patch_by_id,
+            isAsync: true,
+            scope: ts_morph_1.Scope.Public,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'fields',
+                    type: (writer) => writer.writeLine(`Partial<${ref.class}Updated>`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`return this._${common_1.ActionKindMapping.patch_by_id}({ ref, fields, trx }).execute()`);
+            },
+        };
+    }
+    _privatePatchById(ref, item) {
+        return {
+            name: `_${common_1.ActionKindMapping.patch_by_id}`,
+            isAsync: false,
+            scope: ts_morph_1.Scope.Private,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'fields',
+                    type: (writer) => writer.writeLine(`Partial<${ref.class}Updated>`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine('const now = DateTime.now().toJSDate()');
+                writer.blankLine();
+                writer.writeLine(`return this.${common_1.SymbolsAliasMapping.postgres}.${common_1.SqlMethodKindMapping.repository}.${common_1.SqlMethodKindMapping.update_row}(`);
+                writer.writeLine(`'${ref.entity}',`);
+                writer.writeLine('{');
+                writer.writeLine(`${ref.item}_id: fields.${ref.item}_id,`);
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition) {
+                        writer.writeLine(`${generator.sqlAlias}: fields.${generator.partition.key},`);
+                    }
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition || !generator.isUpdated) {
+                        continue;
+                    }
+                    writer.writeLine(`...(fields.${generator.sqlAlias} && { ${generator.sqlAlias}: fields.${generator.sqlAlias} }),`);
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine('trx,');
+                writer.writeLine(`returning: ['id'],`);
+                writer.writeLine(`strictness: 'weak',`);
+                writer.writeLine('},');
+                writer.writeLine(')');
+            },
+        };
+    }
+    _publicDeleteModifyById(ref) {
+        return {
+            name: common_1.ActionKindMapping.delete_modify_by_id,
+            isAsync: true,
+            scope: ts_morph_1.Scope.Public,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'mode',
+                    type: (writer) => writer.writeLine(`'delete' | 'restore'`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`return this._${common_1.ActionKindMapping.delete_modify_by_id}({ ref, mode, trx }).execute()`);
+            },
+        };
+    }
+    _privateDeleteModifyById(ref, item) {
+        return {
+            name: `_${common_1.ActionKindMapping.delete_modify_by_id}`,
+            isAsync: false,
+            scope: ts_morph_1.Scope.Private,
+            parameters: [
+                {
+                    name: 'args',
+                    type: (writer) => {
+                        writer.writeLine(`{ ref: ${ref.class}Ref, mode: 'delete' | 'restore', trx?: Knex.Transaction  }`);
+                    },
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`const { ref, mode, trx } = args`);
+                writer.writeLine('const now = DateTime.now().toJSDate()');
+                writer.blankLine();
+                writer.writeLine(`return this.${common_1.SymbolsAliasMapping.postgres}.${common_1.SqlMethodKindMapping.repository}.${common_1.SqlMethodKindMapping.update_row}(`);
+                writer.writeLine(`'${ref.entity}',`);
+                writer.writeLine('{');
+                writer.writeLine(`${ref.item}_id: fields.${ref.item}_id,`);
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition) {
+                        writer.writeLine(`${generator.sqlAlias}: fields.${generator.partition.key},`);
+                    }
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine(`deleted_at: mode === 'restore' ? null : now,`);
+                writer.writeLine('updated_at: now');
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine('trx,');
+                writer.writeLine('},');
+                writer.writeLine(')');
+            },
+        };
+    }
+    _publicArchiveModifyById(ref) {
+        return {
+            name: common_1.ActionKindMapping.archive_modify_by_id,
+            isAsync: true,
+            scope: ts_morph_1.Scope.Public,
+            parameters: [
+                {
+                    name: 'ref',
+                    type: (writer) => writer.writeLine(`${ref.class}Ref`),
+                },
+                {
+                    name: 'mode',
+                    type: (writer) => writer.writeLine(`'archive' | 'unarchive'`),
+                },
+                {
+                    name: 'trx',
+                    isOptional: true,
+                    type: (writer) => writer.writeLine('Knex.Transaction'),
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`return this._${common_1.ActionKindMapping.archive_modify_by_id}({ ref, mode, trx }).execute()`);
+            },
+        };
+    }
+    _privateArchiveModifyById(ref, item) {
+        return {
+            name: `_${common_1.ActionKindMapping.archive_modify_by_id}`,
+            isAsync: false,
+            scope: ts_morph_1.Scope.Private,
+            parameters: [
+                {
+                    name: 'args',
+                    type: (writer) => {
+                        writer.writeLine(`{ ref: ${ref.class}Ref, mode: 'archive' | 'unarchive', trx?: Knex.Transaction  }`);
+                    },
+                },
+            ],
+            body: (writer) => {
+                writer.writeLine(`const { ref, mode, trx } = args`);
+                writer.writeLine('const now = DateTime.now().toJSDate()');
+                writer.blankLine();
+                writer.writeLine(`return this.${common_1.SymbolsAliasMapping.postgres}.${common_1.SqlMethodKindMapping.repository}.${common_1.SqlMethodKindMapping.update_row}(`);
+                writer.writeLine(`'${ref.entity}',`);
+                writer.writeLine('{');
+                writer.writeLine(`${ref.item}_id: fields.${ref.item}_id,`);
+                for (const [_, { generator }] of Object.entries(item)) {
+                    if (generator.partition) {
+                        writer.writeLine(`${generator.sqlAlias}: fields.${generator.partition.key},`);
+                    }
+                }
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine(`archive_at: mode === 'unarchive' ? null : now,`);
+                writer.writeLine('updated_at: now');
+                writer.writeLine('},');
+                writer.writeLine('{');
+                writer.writeLine('trx,');
+                writer.writeLine('},');
+                writer.writeLine(')');
+            },
+        };
+    }
+}
+exports.PostgresRepositoryTemplate = PostgresRepositoryTemplate;