@trayio/generator 0.0.1-beta

package/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Tray.io, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+Tray Template Generator allows users to create customized templates by replacing specific placeholders with user-provided values. It supports both zip files and folders
+
+### Usage
+
+```typescript
+import { NodeFsGenerator } from '@trayio/generator';
+	
+const templatePath = 'path/to/template';
+const outputPath = 'output/path';
+const values = {
+	name: 'foo',
+	};
+
+const generator = new NodeFsGenerator();
+await generator.generate(
+	templatePath,
+	outputPath,
+	values
+)();
+```
+
+### Template Source
+
+The template source can be either a zip file or a folder. If the template is a zip file, ensure the file extension is `.zip`. If it's a folder, provide the path to the folder.
+
+### Placeholder Syntax
+
+Placeholders could be defined using the `$placeholder$` syntax on file/folder names or withing the content of files.

package/dist/generator/Generator.d.ts

@@ -0,0 +1,5 @@
+import * as TE from 'fp-ts/TaskEither';
+export interface Generator {
+    generate(templatePath: string, targetPath: string, values: Record<string, string>): TE.TaskEither<Error, undefined>;
+}
+//# sourceMappingURL=Generator.d.ts.map

package/dist/generator/Generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Generator.d.ts","sourceRoot":"","sources":["../../src/generator/Generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEvC,MAAM,WAAW,SAAS;IACzB,QAAQ,CACP,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;CACnC"}

package/dist/generator/Generator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generator/NodeFsGenerator.d.ts

@@ -0,0 +1,17 @@
+import * as TE from 'fp-ts/TaskEither';
+import { Generator } from './Generator';
+export declare class NodeFsGenerator implements Generator {
+    generate(templatePath: string, targetPath: string, values: Record<string, string>): TE.TaskEither<Error, undefined>;
+    private replacePlaceholdersInDir;
+    private renameParentDir;
+    private replacePlaceholdersInFile;
+    private replacePlaceholdersInContent;
+    private readStats;
+    private readDir;
+    private readFile;
+    private writeFile;
+    private rename;
+    private copy;
+    private unzip;
+}
+//# sourceMappingURL=NodeFsGenerator.d.ts.map

package/dist/generator/NodeFsGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeFsGenerator.d.ts","sourceRoot":"","sources":["../../src/generator/NodeFsGenerator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAOvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,eAAgB,YAAW,SAAS;IAChD,QAAQ,CACP,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,SAAS,CAAC;IAyBlC,OAAO,CAAC,wBAAwB,CA0B9B;IAEF,OAAO,CAAC,eAAe,CAsCrB;IAEF,OAAO,CAAC,yBAAyB,CAa/B;IAEF,OAAO,CAAC,4BAA4B,CAUlC;IAEF,OAAO,CAAC,SAAS,CACiD;IAElE,OAAO,CAAC,OAAO,CAGZ;IAEH,OAAO,CAAC,QAAQ,CAGb;IAEH,OAAO,CAAC,SAAS,CASd;IAEH,OAAO,CAAC,MAAM,CASX;IAEH,OAAO,CAAC,IAAI,CAST;IAEH,OAAO,CAAC,KAAK,CAYV;CACH"}

package/dist/generator/NodeFsGenerator.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFsGenerator = void 0;
+const fs = __importStar(require("fs/promises"));
+const path_1 = require("path");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const Task_1 = require("@trayio/commons/task/Task");
+const function_1 = require("fp-ts/function");
+const fse = __importStar(require("fs-extra"));
+const Array_1 = require("fp-ts/Array");
+const extract = require("extract-zip");
+class NodeFsGenerator {
+    constructor() {
+        this.replacePlaceholdersInDir = (dirPath, values) => {
+            const targetPath = this.replacePlaceholdersInContent(dirPath, values);
+            return (0, function_1.pipe)(this.rename(dirPath, targetPath), TE.chain(() => this.readDir(targetPath)), TE.chain((direntList) => (0, Array_1.traverse)(TE.ApplicativeSeq)((dirent) => {
+                const fileOrDirPath = (0, path_1.join)(targetPath, dirent.name);
+                if (dirent.isDirectory()) {
+                    return this.replacePlaceholdersInDir(fileOrDirPath, values);
+                }
+                if (dirent.isFile()) {
+                    return this.replacePlaceholdersInFile(fileOrDirPath, values);
+                }
+                return TE.left(new Error('Unknown file type. Template directory should contain either folders or files'));
+            })(direntList)), TE.map(() => undefined));
+        };
+        this.renameParentDir = (targetPath, values) => {
+            const regex = /\$(.*?)\$/g;
+            return (0, function_1.pipe)(this.readDir(targetPath), TE.chain((direntList) => TE.right(direntList.filter((dirent) => regex.test(dirent.name)))), TE.chain((direntList) => {
+                if (direntList.length === 0) {
+                    return TE.right(targetPath);
+                }
+                if (direntList.length > 1) {
+                    return TE.left(new Error('More than one parent directory found. This is not allowed'));
+                }
+                return TE.right(`${targetPath}/${direntList[0].name}`);
+            }), TE.chain((parentDirName) => {
+                const replacedParentDirName = this.replacePlaceholdersInContent(parentDirName, values);
+                return (0, function_1.pipe)(this.rename(parentDirName, replacedParentDirName), TE.map(() => replacedParentDirName));
+            }));
+        };
+        this.replacePlaceholdersInFile = (filePath, values) => {
+            const targetPath = this.replacePlaceholdersInContent(filePath, values);
+            return (0, function_1.pipe)(this.rename(filePath, targetPath), TE.chain(() => this.readFile(targetPath)), TE.map((fileContent) => this.replacePlaceholdersInContent(fileContent, values)), TE.chain((replacedContent) => this.writeFile(targetPath, replacedContent)));
+        };
+        this.replacePlaceholdersInContent = (templateContent, replacements) => {
+            let content = templateContent;
+            Object.entries(replacements).forEach(([placeholder, value]) => {
+                const regex = new RegExp(`\\$${placeholder}\\$`, 'g');
+                content = content.replace(regex, value);
+            });
+            return content;
+        };
+        this.readStats = (path) => (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.lstat(path));
+        this.readDir = (path) => (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.readdir(path, { withFileTypes: true }));
+        this.readFile = (path) => (0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.readFile(path, 'utf-8'));
+        this.writeFile = (targetPath, generatedContent) => (0, function_1.pipe)((0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fs.writeFile(targetPath, generatedContent)), TE.map(() => undefined));
+        this.rename = (oldPath, newPath) => (0, function_1.pipe)((0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fse.rename(oldPath, newPath)), TE.map(() => undefined));
+        this.copy = (source, targetPath) => (0, function_1.pipe)((0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => fse.copy(source, targetPath)), TE.map(() => undefined));
+        this.unzip = (source, targetPath) => (0, function_1.pipe)((0, Task_1.createTaskEitherFromPromiseWithSimpleError)(() => {
+            const extracted = extract(source, {
+                dir: targetPath,
+            });
+            return extracted;
+        }), TE.map(() => undefined));
+    }
+    generate(templatePath, targetPath, values) {
+        return (0, function_1.pipe)(this.readStats(templatePath), TE.chain((stats) => {
+            if (stats.isDirectory()) {
+                return this.copy(templatePath, targetPath);
+            }
+            if (stats.isFile() && (0, path_1.extname)(templatePath) === '.zip') {
+                const unzip = this.unzip(templatePath, targetPath);
+                return unzip;
+            }
+            return TE.left(new Error('Unknown file type. Template path needs to be either a directory or a zip file'));
+        }), TE.chain(() => this.renameParentDir(targetPath, values)), TE.chain((parentDirName) => this.replacePlaceholdersInDir(parentDirName, values)), TE.map(() => undefined));
+    }
+}
+exports.NodeFsGenerator = NodeFsGenerator;

package/dist/generator/NodeFsGenerator.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=NodeFsGenerator.unit.test.d.ts.map

package/dist/generator/NodeFsGenerator.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeFsGenerator.unit.test.d.ts","sourceRoot":"","sources":["../../src/generator/NodeFsGenerator.unit.test.ts"],"names":[],"mappings":""}

package/dist/generator/NodeFsGenerator.unit.test.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path_1 = require("path");
+const extract = require("extract-zip");
+const NodeFsGenerator_1 = require("./NodeFsGenerator");
+const unzip = (source, targetPath) => extract(source, {
+    dir: targetPath,
+});
+const outputTest = (outputPath, values) => {
+    const dirContent = fs.readdirSync(outputPath);
+    expect(dirContent).toStrictEqual(expect.arrayContaining([values.name]));
+    const serviceDirPath = (0, path_1.join)(outputPath, values.name);
+    const serviceDirContent = fs.readdirSync(serviceDirPath);
+    expect(serviceDirContent).toEqual(expect.arrayContaining([
+        '.github',
+        '.gitignore',
+        'README.md',
+        'modules',
+        'package.json',
+    ]));
+    const modulesDir = (0, path_1.join)(serviceDirPath, `modules`);
+    const modulesDirDirContent = fs.readdirSync(modulesDir);
+    expect(modulesDirDirContent).toEqual(expect.arrayContaining([`${values.name}-contract`, `${values.name}-domain`]));
+    return undefined;
+};
+const contentTest = (outputPath, values) => {
+    const filePath = (0, path_1.join)(outputPath, `${values.name}/modules/${values.name}-contract/src/${values.entityFolder}/${values.entity}Facade.ts`);
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const expectedContent = `import { RequestHandler } from '@trayio/base-contract/base/Facade';
+import { TypeCodec } from '@trayio/commons/codec/TypeCodec';
+import * as t from 'io-ts';
+
+export interface ${values.entity}Facade {
+	get${values.entity}: RequestHandler<Get${values.entity}, ${values.entity}>;
+	create${values.entity}: RequestHandler<Create${values.entity}, ${values.entity}>;
+}
+
+export type Get${values.entity} = {
+	id: string;
+};
+
+export type Create${values.entity} = {
+	description: string;
+};
+
+export type ${values.entity} = {
+	id: string;
+	description: string;
+};
+
+export const get${values.entity}Codec = new TypeCodec<Get${values.entity}>(
+	t.type({
+		id: t.string,
+	})
+);
+
+export const create${values.entity}Codec = new TypeCodec<Create${values.entity}>(
+	t.type({
+		description: t.string,
+	})
+);
+
+export const ${values.entityVar}Codec = new TypeCodec<${values.entity}>(
+	t.type({
+		id: t.string,
+		description: t.string,
+	})
+);
+`;
+    expect(fileContent).toEqual(expectedContent);
+};
+/** test directory structure:
+ * 	- generator-test-output
+ * 		- zip-test
+ * 		- folder-test-template
+ * 		- folder-test-output
+ */
+describe('NodeFsGenerator', () => {
+    const dirPath = __dirname;
+    const outputPath = (0, path_1.join)(dirPath, 'generator-test-output');
+    const zipTemplatePath = (0, path_1.join)(dirPath, 'project.test.zip');
+    const values = {
+        name: 'cluster-service',
+        entityFolder: 'foo',
+        entityVar: 'foo',
+        entity: 'Foo',
+    };
+    try {
+        fs.mkdirSync(outputPath);
+    }
+    catch (error) {
+        // ignore error
+    }
+    // comment out to see output
+    afterAll(() => {
+        fs.rmSync(outputPath, { recursive: true, force: true });
+    });
+    describe('zip template', () => {
+        const zipOutputPath = (0, path_1.join)(outputPath, 'zip-test');
+        fs.mkdirSync(zipOutputPath, {
+            recursive: true,
+        });
+        it('Should extract all content of the template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const generator = new NodeFsGenerator_1.NodeFsGenerator();
+            yield generator.generate(zipTemplatePath, zipOutputPath, values)();
+        }));
+        it('should output template and rename files/folders according to user input', () => {
+            outputTest(zipOutputPath, values);
+        });
+        it('should update the content of files according to user input', () => {
+            contentTest(zipOutputPath, values);
+        });
+    });
+    describe('folder template', () => {
+        const folderTemplatePath = (0, path_1.join)(outputPath, 'folder-test-template');
+        const folderOutputPath = (0, path_1.join)(outputPath, 'folder-test-output');
+        fs.mkdirSync(folderTemplatePath, {
+            recursive: true,
+        });
+        fs.mkdirSync(folderOutputPath, {
+            recursive: true,
+        });
+        unzip(zipTemplatePath, folderTemplatePath);
+        it('Should copy all content of the template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const generator = new NodeFsGenerator_1.NodeFsGenerator();
+            const result = yield generator.generate(folderTemplatePath, folderOutputPath, values)();
+        }));
+        it('should output template and rename files/folders according to user input', () => {
+            outputTest(folderOutputPath, values);
+        });
+        it('should update the content of files according to user input', () => {
+            contentTest(folderOutputPath, values);
+        });
+    });
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@trayio/generator",
+  "version": "0.0.1-beta",
+  "description": "Template based generator",
+  "author": "Tray.io",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@trayio/commons": "0.0.1-beta",
+    "extract-zip": "2.0.1",
+    "fs-extra": "11.1.0"
+  },
+  "exports": {
+    "./*": "./dist/*.js"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*"
+      ]
+    }
+  },
+  "files": [
+    "/dist"
+  ]
+}