miqro 4.0.1 → 5.0.1

package/build/cli.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { CMD_MAP, usage } from "./cmd-map.js";
-import { mainCMD } from "./utils/index.js";
+import { mainCMD } from "./utils/exec.js";
 mainCMD(CMD_MAP, usage, console);

package/build/cmd-map.d.ts

@@ -1,4 +1,3 @@
-import { main as help } from "./cmds/help.js";
 export declare const usage = "npx miqro <command> [args]";
 export declare const CMD_MAP: {
     "new:api": {
@@ -53,12 +52,12 @@ export declare const CMD_MAP: {
     };
     start: {
         tabs: number;
-        cb: () => void;
+        cb: typeof start;
         description: string;
     };
     cluster: {
         tabs: number;
-        cb: () => void;
+        cb: typeof start;
         description: string;
     };
     watch: {
@@ -72,8 +71,10 @@ export declare const CMD_MAP: {
         description: string;
     };
     help: {
-        cb: typeof help;
+        cb: () => void;
         tabs: number;
         description: string;
     };
 };
+declare function start(): void;
+export {};

package/build/cmd-map.js

@@ -1,66 +1,275 @@
-import { main as start } from "./cmds/start.js";
-import { main as watch } from "./cmds/watch.js";
-import { mainTS as newTS } from "./cmds/new.js";
-import { main as apiDocJSON } from "./cmds/doc-json.js";
-import { main as apiDocMD } from "./cmds/doc-md.js";
-import { main as configInit } from "./cmds/config-init.js";
-import { main as config } from "./cmds/config.js";
-import { main as configBash } from "./cmds/config-bash.js";
-import { main as configEnv } from "./cmds/config-env.js";
-import { main as newRoute } from "./cmds/handler-apiroute-new.js";
-import { main as newTest } from "./cmds/new-test.js";
-import { main as serve } from "./cmds/serve.js";
-import { main as help } from "./cmds/help.js";
-import { main as newMain } from "./cmds/handler-main-new.js";
+import { resolve } from "path";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { apiRouteTemplate, gitignoreTemplate, mainTemplates, packageTemplate, templates, testTemplates } from "./utils/templates.js";
+import { App, ConfigPathResolver, LoggerHandler, Proxy, ReadBuffer, Static, loadConfig, normalizePath } from "@miqro/core";
+import { getDOCJSON } from "./utils/doc/json.js";
+import { getMDDoc } from "./utils/doc/md.js";
+import { mainPath } from "@miqro/runner";
+import { setupWatch } from "./utils/watch.js";
+import { extractFlags, getUsage, execSync } from "./utils/exec.js";
 export const usage = "npx miqro <command> [args]";
 export const CMD_MAP = {
     ["new:api"]: {
         //section: "api development", 
-        cb: newTS, tabs: 4, description: `create a new project.`
+        cb: () => {
+            const usageTS = `usage: npx miqro new:api <identifier ex: NEW_APP>`;
+            if (process.argv.length !== 4 || process.argv[3].length < 1) {
+                throw new Error(usageTS);
+            }
+            const identifier = process.argv[3].toLocaleLowerCase();
+            const appFolder = resolve(process.cwd(), identifier);
+            if (existsSync(appFolder)) {
+                throw new Error(`${appFolder} already exists!`);
+            }
+            console.log(`creating ${appFolder}`);
+            mkdirSync(appFolder, {
+                recursive: true
+            });
+            writeFileSync(resolve(appFolder, "package.json"), packageTemplate["ts"](identifier));
+            execSync(`npm install miqro --save-dev`, {
+                cwd: appFolder
+            });
+            execSync(`npm install @miqro/core --save`, {
+                cwd: appFolder
+            });
+            writeFileSync(resolve(appFolder, "tsconfig.json"), `{
+      "compileOnSave": true,
+      "compilerOptions": {
+        "lib": ["es2021"],
+        "module": "Node16",
+        "moduleResolution": "Node16",
+        "target": "es2021",
+        "strict": false,
+        "outDir": "./build/",
+        "removeComments": true,
+        "noImplicitAny": false,
+        "preserveConstEnums": true,
+        "sourceMap": true,
+        "esModuleInterop": true,
+        "declaration": true
+      },
+      "exclude": [
+        "node_modules",
+        "test"
+      ],
+      "include": [
+        "src"
+      ]
+    }`);
+            execSync(`npm install typescript --save-dev`, {
+                cwd: appFolder
+            });
+            execSync(`npm install @types/node --save-dev`, {
+                cwd: appFolder
+            });
+            writeFileSync(resolve(appFolder, ".gitignore"), gitignoreTemplate.ts());
+            execSync(`npm install @miqro/test-http --save-dev`, {
+                cwd: appFolder
+            });
+            execSync(`npx miqro new:api:main src_main`, {
+                cwd: appFolder
+            });
+            execSync(`npx miqro new:api:route src_api_health`, {
+                cwd: appFolder
+            });
+            mkdirSync(resolve(appFolder, "test"), {
+                recursive: true
+            });
+            execSync(`npx miqro new:api:route:test test_api_health`, {
+                cwd: appFolder
+            });
+            console.log("");
+            console.log("");
+            console.log(`new project created on ${appFolder}`);
+            console.log(`cd ${identifier}`);
+            console.log(`npm run start`);
+            console.log("");
+        }, tabs: 4, description: `create a new project.`
     },
-    //["new:typescript"]: {cb: newTS, tabs: 4, description: `create a new typescript project.`},
     ["new:api:main"]: {
         //section: "http scaffolding",
-        cb: newMain,
+        cb: () => {
+            if (process.argv.length !== 4 || process.argv[3].length < 1) {
+                throw new Error(`usage: [NODE_ENV=development] npx miqro new:api:main <identifier ex: NEW_APP>`);
+            }
+            const identifier = process.argv[3].toLocaleLowerCase();
+            const split = identifier.split("_");
+            const dots = split.filter(s => s.indexOf(".") !== -1);
+            if (dots.length > 0) {
+                throw new Error(`identifier cannot contain dots\narguments: <identifier ex: SRC_MAIN>`);
+            }
+            loadConfig();
+            const path = resolve(ConfigPathResolver.getBaseDirname(), ...split.splice(0, split.length - 1));
+            const ext = existsSync(resolve(ConfigPathResolver.getBaseDirname(), "tsconfig.json")) ? "ts" : "js";
+            const filePath = resolve(path, `${split[0]}.${ext}`);
+            if (existsSync(filePath)) {
+                throw new Error(`file ${filePath} already exists! doing nothing`);
+            }
+            console.log(`creating ${filePath}`);
+            mkdirSync(path, {
+                recursive: true
+            });
+            writeFileSync(filePath, mainTemplates[ext]());
+            console.log(`file ${filePath} created`);
+        },
         tabs: 3,
         description: `creates a new main file.`
     },
-    ["new:api:route"]: { cb: newRoute, tabs: 3, description: `creates a new route.` },
-    ["new:api:route:test"]: { cb: newTest, tabs: 2, description: `create new test.js file for an APIRouter.` },
+    ["new:api:route"]: {
+        cb: () => {
+            const nUsage = `usage: [NODE_ENV=development] npx miqro new:api:main <identifier ex: NEW_APP>`;
+            if (process.argv.length !== 4 || process.argv[3].length < 1) {
+                throw new Error(nUsage);
+            }
+            const identifier = process.argv[3].toLocaleLowerCase();
+            const split = identifier.split("_").map(s => s.trim()).filter(s => s);
+            const dots = split.filter(s => s.indexOf(".") !== -1);
+            if (dots.length > 0) {
+                throw new Error(`identifier cannot contain dots\n${nUsage}`);
+            }
+            loadConfig();
+            const path = resolve(ConfigPathResolver.getBaseDirname(), ...split.splice(0, split.length - 1));
+            const ext = existsSync(resolve(ConfigPathResolver.getBaseDirname(), "tsconfig.json")) ? "ts" : "js";
+            const noMethod = ["post", "get", "put", "delete", "patch", "options"].indexOf(split[0].toLocaleLowerCase()) === -1;
+            const filePath = resolve(path, `${split[0]}.${ext}`);
+            if (existsSync(filePath)) {
+                throw new Error(`file ${filePath} already exists! doing nothing`);
+            }
+            console.log(`creating ${filePath}`);
+            mkdirSync(path, {
+                recursive: true
+            });
+            writeFileSync(filePath, apiRouteTemplate[ext](noMethod));
+        }, tabs: 3, description: `creates a new route.`
+    },
+    ["new:api:route:test"]: {
+        cb: () => {
+            if (process.argv.length !== 4 || process.argv[3].length < 1) {
+                throw new Error(`usage: [NODE_ENV=development] npx miqro new:test <identifier ex: TEST_SOMEFILE>`);
+            }
+            const identifier = process.argv[3].toLocaleLowerCase();
+            const split = identifier.split("_");
+            const dots = split.filter(s => s.indexOf(".") !== -1);
+            if (dots.length > 0) {
+                throw new Error(`identifier cannot contain dots\narguments: <identifier ex: TEST_SOMETEST>`);
+            }
+            loadConfig();
+            const path = resolve(ConfigPathResolver.getBaseDirname(), ...split.splice(0, split.length - 1));
+            const filePath = resolve(path, `${split[0]}.test.js`);
+            if (existsSync(filePath)) {
+                throw new Error(`file ${filePath} already exists! doing nothing`);
+            }
+            console.log(`creating ${filePath}`);
+            mkdirSync(path, {
+                recursive: true
+            });
+            writeFileSync(filePath, testTemplates.js(split[0]));
+            console.log(`file ${filePath} created`);
+        }, tabs: 2, description: `create new test.js file for an APIRouter.`
+    },
     ["config"]: {
         //section: "config management",
-        cb: config,
+        cb: () => {
+            const logger = console;
+            if (process.argv.length !== 3) {
+                throw new Error(`invalid number of args. ${"usage: [NODE_ENV=development] npx miqro config"}`);
+            }
+            const configOut = loadConfig();
+            const config = configOut.combined;
+            logger.info(JSON.stringify(config, undefined, 2));
+        },
         tabs: 4,
         description: `print config as a json.`
     },
     ["config:bash"]: {
-        cb: configBash,
+        cb: () => {
+            const logger = console;
+            if (process.argv.length !== 3) {
+                throw new Error(`invalid number of args. usage: [NODE_ENV=development] npx miqro config:bash`);
+            }
+            const configOut = loadConfig();
+            const config = configOut.combined;
+            const keys = Object.keys(config);
+            for (const key of keys) {
+                logger.info(`export ${key}=${config[key]}`);
+            }
+        },
         tabs: 3,
         description: `print config as a bash script.`
     },
     ["config:env"]: {
-        cb: configEnv,
+        cb: () => {
+            const logger = console;
+            if (process.argv.length !== 3) {
+                throw new Error(`invalid number of args. usage: [NODE_ENV=development] npx miqro config:env`);
+            }
+            const configOut = loadConfig();
+            const config = configOut.combined;
+            const keys = Object.keys(config);
+            for (const key of keys) {
+                logger.info(`${key}=${config[key]}`);
+            }
+        },
         tabs: 3,
         description: `print config as a env file.`
     },
-    ["config:init"]: { cb: configInit, tabs: 3, description: `inits your config folder.` },
+    ["config:init"]: {
+        cb: () => {
+            const logger = console;
+            if (process.argv.length !== 3) {
+                throw new Error(`invalid number of args. usage: [NODE_ENV=development] npx miqro config:init`);
+            }
+            loadConfig();
+            const configPath = ConfigPathResolver.getConfigDirname();
+            const initEnvFile = (path, template) => {
+                if (!existsSync(path)) {
+                    logger.warn(`creating ${path} env file`);
+                    writeFileSync(path, template);
+                }
+                else {
+                    logger.warn(`${path} already exists!. init will not create it.`);
+                }
+            };
+            if (!existsSync(configPath)) {
+                logger.warn(`[${configPath}] doesnt exists!`);
+                mkdirSync(configPath, {
+                    recursive: true
+                });
+            }
+            initEnvFile(resolve(configPath, `log.env`), templates.logEnvFile);
+            initEnvFile(resolve(configPath, `auth.env`), templates.authEnvFile);
+            initEnvFile(resolve(configPath, `features.env`), templates.featuresEnvFile);
+        }, tabs: 3, description: `inits your config folder.`
+    },
     ["doc"]: {
         //section: "api documentation",
         tabs: 4,
-        cb: apiDocJSON,
+        cb: async () => {
+            if (process.argv.length < 5 || process.argv.length > 6) {
+                throw new Error(`usage: [NODE_ENV=development] npx miqro doc <api_folder> <subPath> [apiName]`);
+            }
+            const dirname = process.argv[3];
+            const subPath = process.argv[4];
+            const apiName = process.argv[5];
+            loadConfig();
+            console.log(JSON.stringify(await getDOCJSON({ dirname, subPath, apiName }), undefined, 2));
+        },
         description: `api folder auto doc as a json.`
     },
     ["doc:md"]: {
-        cb: apiDocMD,
+        cb: async () => {
+            if (process.argv.length < 5 || process.argv.length > 6) {
+                throw new Error(`usage: [NODE_ENV=development] npx miqro doc <api_folder> <subPath> [apiName]`);
+            }
+            const dirname = process.argv[3];
+            const subPath = process.argv[4];
+            const apiName = process.argv[5];
+            loadConfig();
+            console.log(await getMDDoc({ dirname, subPath, apiName }));
+        },
         tabs: 4,
         description: `api folder auto doc as a markdown.`
     },
-    /*["new:front"]: {
-      section: "front end development",
-      cb: newTSFront,
-      tabs: 3,
-      description: `create a new web-components project.`
-    },*/
     ["start"]: {
         //section: "start helpers",
         tabs: 4,
@@ -74,18 +283,113 @@ export const CMD_MAP = {
     },
     ["watch"]: {
         //section: "watch",
-        cb: watch,
+        cb: () => {
+            const usageMessage = (message) => `${message ? `${message}.\n` : ""}usage: npx miqro watch <directory> <cmd>`;
+            if (process.argv.length < 5) {
+                throw new Error(usageMessage("invalid number of args"));
+            }
+            const directory = process.argv[3];
+            const cmd = process.argv.slice(4).join(" ");
+            const timeout = process.env.WATCH_TIMEOUT ? parseInt(process.env.WATCH_TIMEOUT, 10) : undefined;
+            if (!existsSync(directory) || !statSync(directory).isDirectory()) {
+                throw new Error(usageMessage("directory not found!"));
+            }
+            console.log(`setting up watch on ${directory} with cmd ${cmd}`);
+            setupWatch(directory, cmd, timeout);
+        },
         tabs: 4,
         description: `watch folder for changes.`
     },
     ["serve"]: {
         //section: "serve static files",
         tabs: 4,
-        cb: serve, description: `serve static files.`
+        cb: async () => {
+            const nUsage = `usage: [NODE_ENV=development] npx miqro serve [directory=./] [path=/] [--index404 ./index.html] [--proxy-cert-ignore] [--port 8080] [--proxy /api=https://host/api]`;
+            const flags = extractFlags(process.argv.slice(3), {
+                flags: {
+                    "help": {
+                        description: "get help page", hasValue: false
+                    },
+                    "index404Status": {
+                        description: "status to handle index404 status", hasValue: true
+                    },
+                    "index404": {
+                        description: "file to handle 404", hasValue: true
+                    }, "proxy": {
+                        description: "proxy", hasValue: true
+                    }, "proxy-cert-ignore": {
+                        description: "proxy ignore certs", hasValue: false
+                    }, "port": {
+                        description: "port", hasValue: true
+                    }
+                }
+            });
+            if (flags.flags.help !== undefined) {
+                console.log(nUsage);
+                process.exit(102);
+            }
+            if (flags.files.length > 2) {
+                throw new Error(`invalid arguments.\n${nUsage}`);
+            }
+            if (flags.flags.index404 instanceof Array) {
+                throw new Error(`invalid index404!.\n${nUsage}`);
+            }
+            if (flags.flags.port instanceof Array) {
+                throw new Error(`invalid port!.\n${nUsage}`);
+            }
+            let [directory, path] = flags.files;
+            path = path ? path : "/";
+            directory = directory ? directory : process.cwd();
+            loadConfig();
+            const PORT = flags.flags.port ? flags.flags.port : (process.env.PORT ? process.env.PORT : 8080);
+            if (PORT === undefined) {
+                throw new Error(`invalid port!.\n${nUsage}`);
+            }
+            if (!existsSync(directory) || !statSync(directory).isDirectory()) {
+                throw new Error(`${directory} directory not found!\n${nUsage}`);
+            }
+            const app = new App();
+            app.use(LoggerHandler());
+            const proxyList = flags.flags.proxy instanceof Array ? flags.flags.proxy : [flags.flags.proxy];
+            for (const proxy of proxyList) {
+                if (proxy) {
+                    const proxySplit = proxy.split("=");
+                    if (proxySplit.length !== 2) {
+                        throw new Error("proxy must be in the form. /path=proxy");
+                    }
+                    const proxyPath = normalizePath(proxySplit[0]);
+                    const proxyURL = new URL(proxySplit[1]);
+                    proxyURL.pathname = normalizePath(proxyURL.pathname);
+                    const proxyRouter = Proxy({
+                        url: proxyURL.toString(), rejectUnauthorized: flags.flags["proxy-cert-ignore"] ? true : false
+                    });
+                    console.log("setting up proxy to %s on %s", proxyURL.toString(), proxyPath);
+                    proxyRouter.use(ReadBuffer());
+                    app.use(proxyRouter, proxyPath);
+                }
+            }
+            app.use(Static({
+                directory,
+                list: true,
+                index404: flags.flags.index404 ? flags.flags.index404 : undefined,
+                index404Status: flags.flags.index404Status ? parseInt(flags.flags.index404Status, 10) : undefined
+            }), path);
+            await app.listen(PORT);
+            console.log("serving " + directory + " on http://localhost:%s%s", PORT, path);
+        }, description: `serve static files.`
     },
     ["help"]: {
         //section: "help",
-        cb: help,
+        cb: () => {
+            console.log(getUsage(CMD_MAP, usage));
+        },
         tabs: 4, description: "prints this page"
     }
 };
+function start() {
+    if (process.argv.length <= 3) {
+        throw new Error(`invalid number of args\nusage: CLUSTER_COUNT=os.cpus().length [CLUSTER_AUTO_BROADCAST=true|false] [CLUSTER_DISABLE_RESTART=true|false] npx miqro start <script> [...args]`);
+    }
+    loadConfig();
+    execSync(`${process.argv[0]} ${mainPath()} ${process.argv.slice(3).join(" ")}`);
+}

package/build/utils/doc/md.js

@@ -29,7 +29,7 @@ export async function getMDDoc(args, logger) {
                 const requestOutMD = parserToString(apiData.request);
                 outMD += requestOutMD !== "" ? `### request\n\n${requestOutMD}` : "";
             }
-            if (apiData.response) {
+            if (apiData.response && typeof apiData.response !== "boolean") {
                 const responseOutMD = parserToString(apiData.response);
                 outMD += responseOutMD !== "" ? `### response\n\n${responseOutMD}` : "";
             }

package/build/utils/{index.d.ts → exec.d.ts}

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { ExecSyncOptionsWithBufferEncoding } from "child_process";
 export declare const execSync: (cmd: string, options?: ExecSyncOptionsWithBufferEncoding) => void;
 export type Callback<T = any> = (...args: any[]) => T;

package/build/utils/templates.d.ts

@@ -1,3 +1,22 @@
+export declare const testTemplates: {
+    js: (category: string) => string;
+};
+export declare const apiRouteTemplate: {
+    ts: (noMethod?: boolean) => "import { APIRoute } from \"@miqro/core\";\n\nexport default {\n  method: \"GET\",\n  handler: async (req, res) => {\n    return {\n      text: `Hello`\n    }\n  }\n} as APIRoute;\n" | "import { APIRoute } from \"@miqro/core\";\n\nexport default {\n  handler: async (req, res) => {\n    return {\n      text: `Hello`\n    }\n  }\n} as APIRoute;\n";
+    js: (noMethod?: boolean) => "module.exports = {\n  method: \"GET\n  handler: async (req, res) => {\n    return {\n      text: `Hello`\n    }\n  }\n};\n" | "module.exports = {\n  handler: async (req, res) => {\n    return {\n      text: `Hello`\n    }\n  }\n};\n";
+};
+export declare const mainTemplates: {
+    ts: () => string;
+    js: () => string;
+};
+export declare const gitignoreTemplate: {
+    ts: () => string;
+    js: () => string;
+};
+export declare const packageTemplate: {
+    ts: (name: string) => string;
+    js: (name: string) => string;
+};
 export declare const logEnvFile = "####################\n## logging\nLOG_LEVEL=info\nLOG_LEVEL_Database=error\n#LOG_FILE=./logs/dev.log\n";
 export declare const featuresEnvFile = "####################\n## features\n#MY_CUSTOM_FEATURE=false\n";
 export declare const dbEnvFile = "####################\n## db\nDB_URI=sqlite://user:password@localhost:3306/devdb\nDB_POOL=false\nDB_DIALECT_SSL=true\nDB_POOL_MAX=5\nDB_POOL_MIN=0\nDB_POOL_ACQUIRE=30000\nDB_POOL_IDLE=10000\nDB_STORAGE=./dev.sqlite3\n";

package/build/utils/templates.js

@@ -1,4 +1,157 @@
 // noinspection SpellCheckingInspection
+export const testTemplates = {
+    js: (category) => `import { it } from "node:test";
+import { TestHelper } from "@miqro/test-http";
+import { Server, APIRouter } from "@miqro/core";
+import { resolve } from "path";
+import { strictEqual } from "assert";
+
+it("happy path health", async () => {
+  const response = await TestHelper(new Server().use(await APIRouter({
+    dirname: resolve("./build/api")
+  })), {
+    url: "/health"
+  });
+  strictEqual(response.status, 200);
+});
+`
+};
+export const apiRouteTemplate = {
+    ts: (noMethod = false) => noMethod ? `import { APIRoute } from "@miqro/core";
+
+export default {
+  method: "GET",
+  handler: async (req, res) => {
+    return {
+      text: \`Hello\`
+    }
+  }
+} as APIRoute;
+` : `import { APIRoute } from "@miqro/core";
+
+export default {
+  handler: async (req, res) => {
+    return {
+      text: \`Hello\`
+    }
+  }
+} as APIRoute;
+`,
+    js: (noMethod = false) => noMethod ? `module.exports = {
+  method: "GET
+  handler: async (req, res) => {
+    return {
+      text: \`Hello\`
+    }
+  }
+};
+` : `module.exports = {
+  handler: async (req, res) => {
+    return {
+      text: \`Hello\`
+    }
+  }
+};
+`
+};
+export const mainTemplates = {
+    ts: () => `import { APIRouter, Server, checkEnvVariables, getLogger } from "@miqro/core";
+import { resolve } from "path";
+
+/*
+To be start as a main file
+node file.js
+*/
+
+const [PORT] = checkEnvVariables(["PORT"], ["8080"]);
+
+const logger = getLogger("server");
+
+async function main() {
+  const server = new Server();
+  server.use(await APIRouter({
+    dirname: resolve("./build/api")
+  }), "/api");
+  await server.listen(PORT);
+  server.logPaths(logger);
+  logger.info("listening on " + PORT);
+}
+
+main().catch(e => logger.error(e));
+`,
+    js: () => `const { APIRouter, App, checkEnvVariables, getLogger } = require("@miqro/core");
+const { resolve } = require("path");
+
+/*
+To be start as a main file
+node file.js
+*/
+
+const [PORT] = checkEnvVariables(["PORT"], ["8080"]);
+
+const logger = getLogger("server");
+
+async function main() {
+  const server = new App();
+  server.use(await APIRouter({
+    dirname: resolve(__dirname, "api")
+  }), "/api");
+  await server.listen(PORT);
+  server.logPaths(logger);
+  logger.info("listening on " + PORT);
+}
+
+main().catch(e => logger.error(e));
+`
+};
+export const gitignoreTemplate = {
+    ts: () => `node_modules/
+dist/
+`,
+    js: () => `node_modules/`
+};
+export const packageTemplate = {
+    ts: (name) => `{
+  "name": "${name}",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {
+    "prebuild": "rm -Rf build/;",
+    "build": "tsc",
+    "prestart": "npm run build",
+    "start": "node --enable-source-maps build/main.js",
+    "cluster": "NODE_OPTIONS=--enable-source-maps miqro cluster build/main.js",
+    "pretest": "npm run build",
+    "test": "node --enable-source-maps --test test/**/*.test.js",
+    "coverage": "node --enable-source-maps --experimental-test-coverage --test test/**/*.test.js"
+  },
+  "devDependencies": {
+  },
+  "dependencies": {
+  },
+  "author": ""
+}`,
+    js: (name) => `{
+  "name": "${name}",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {
+    "start": "node src/main.js",
+    "cluster": "miqro cluster src/main.js",
+    "test": "node --test test/**/*.test.js",
+    "coverage": "node --experimental-test-coverage --test test/**/*.test.js"
+  },
+  "devDependencies": {
+  },
+  "dependencies": {
+  },
+  "author": ""
+}`
+};
 export const logEnvFile = `####################
 ## logging
 LOG_LEVEL=info

package/build/utils/watch.d.ts

@@ -0,0 +1 @@
+export declare function setupWatch(directory: string, cmd: string, timeout?: number): void;