create-jwn-js 1.0.1

package/README.md

@@ -0,0 +1,8 @@
+## create-jwn-js
+
+Create jwn-js utility
+
+
+```bash
+    yarn create jwn-js project-name
+```

package/index.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const margv = require('margv')
+const argv = margv();
+const prompts = require('prompts');
+
+const {
+    yellow,
+    blue,
+    red
+} = require('kolorist')
+const cwd = process.cwd()
+const FRAMEWORKS = [
+    {
+        name: 'vite',
+        color: yellow,
+        variants: [
+            {
+                name: 'vite-node-ts',
+                display: 'TypeScript',
+                color: blue
+            }
+        ]
+    }
+]
+const TEMPLATES = FRAMEWORKS.map(
+    (f) => (f.variants && f.variants.map((v) => v.name)) || [f.name]
+).reduce((a, b) => a.concat(b), []);
+
+const renameFiles = {
+    _gitignore: '.gitignore'
+}
+
+async function init() {
+    let targetDir = argv["$"][2];
+    let template = argv.template || argv.t
+    const defaultProjectName = targetDir || 'vite-node';
+    let result = {}
+
+    try {
+        result = await prompts(
+            [
+                {
+                    type: targetDir ? null : 'text',
+                    name: 'projectName',
+                    message: 'Project name:',
+                    initial: defaultProjectName,
+                    onState: (state) =>
+                        (targetDir = state.value.trim() || defaultProjectName)
+                },
+                {
+                    type: () =>
+                        !fs.existsSync(targetDir) || isEmpty(targetDir) ? null : 'confirm',
+                    name: 'overwrite',
+                    message: () =>
+                        (targetDir === '.'
+                            ? 'Current directory'
+                            : `Target directory "${targetDir}"`) +
+                        ` is not empty. Remove existing files and continue?`
+                },
+                {
+                    type: (_, { overwrite } = {}) => {
+                        if (overwrite === false) {
+                            throw new Error(red('✖') + ' Operation cancelled')
+                        }
+                        return null
+                    },
+                    name: 'overwriteChecker'
+                },
+                {
+                    type: () => (isValidPackageName(targetDir) ? null : 'text'),
+                    name: 'packageName',
+                    message: 'Package name:',
+                    initial: () => toValidPackageName(targetDir),
+                    validate: (dir) =>
+                        isValidPackageName(dir) || 'Invalid package.json name'
+                },
+                {
+                    type: template && TEMPLATES.includes(template) ? null : 'select',
+                    name: 'framework',
+                    message:
+                        typeof template === 'string' && !TEMPLATES.includes(template)
+                            ? `"${template}" isn't a valid template. Please choose from below: `
+                            : 'Select a framework:',
+                    initial: 0,
+                    choices: FRAMEWORKS.map((framework) => {
+                        const frameworkColor = framework.color;
+
+                        return {
+                            title: frameworkColor(framework.name),
+                            value: framework
+                        }
+                    })
+                },
+                {
+                    type: (framework) =>
+                        framework && framework.variants ? 'select' : null,
+                    name: 'variant',
+                    message: 'Select a variant:',
+                    // @ts-ignore
+                    choices: (framework) =>
+                        framework.variants.map((variant) => {
+                            const variantColor = variant.color
+                            return {
+                                title: variantColor(variant.name),
+                                value: variant.name
+                            }
+                        })
+                }
+            ],
+            {
+                onCancel: () => {
+                    throw new Error(red('✖') + ' Operation cancelled')
+                }
+            }
+        )
+    } catch (cancelled) {
+        console.log(cancelled.message);
+
+        return
+    }
+
+    // user choice associated with prompts
+    const { framework, overwrite, packageName, variant } = result
+
+    const root = path.join(cwd, targetDir)
+
+    if (overwrite) {
+        emptyDir(root)
+    } else if (!fs.existsSync(root)) {
+        fs.mkdirSync(root)
+    }
+
+    // determine template
+    template = variant || framework || template
+
+    console.log(`\nScaffolding project in ${root}...`)
+
+    const templateDir = path.join(__dirname, `template-${template}`)
+
+    const write = (file, content) => {
+        const targetPath = renameFiles[file]
+            ? path.join(root, renameFiles[file])
+            : path.join(root, file)
+        if (content) {
+            fs.writeFileSync(targetPath, content)
+        } else {
+            copy(path.join(templateDir, file), targetPath)
+        }
+    }
+
+    const files = fs.readdirSync(templateDir)
+    for (const file of files.filter((f) => f !== 'package.json')) {
+        write(file)
+    }
+
+    const pkg = require(path.join(templateDir, `package.json`))
+
+    pkg.name = packageName || targetDir
+
+    write('package.json', JSON.stringify(pkg, null, 2))
+
+    const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent)
+    const pkgManager = pkgInfo ? pkgInfo.name : 'npm'
+
+    console.log(`\nDone. Now run:\n`)
+    if (root !== cwd) {
+        console.log(`  cd ${path.relative(cwd, root)}`)
+    }
+    switch (pkgManager) {
+        case 'yarn':
+            console.log('  yarn')
+            console.log('  yarn dev')
+            break
+        default:
+            console.log(`  ${pkgManager} install`)
+            console.log(`  ${pkgManager} run dev`)
+            break
+    }
+    console.log()
+}
+
+function copy(src, dest) {
+    const stat = fs.statSync(src)
+    if (stat.isDirectory()) {
+        copyDir(src, dest)
+    } else {
+        fs.copyFileSync(src, dest)
+    }
+}
+
+function isValidPackageName(projectName) {
+    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(
+        projectName
+    )
+}
+
+function toValidPackageName(projectName) {
+    return projectName
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/^[._]/, '')
+        .replace(/[^a-z0-9-~]+/g, '-')
+}
+
+function copyDir(srcDir, destDir) {
+    fs.mkdirSync(destDir, { recursive: true })
+    for (const file of fs.readdirSync(srcDir)) {
+        const srcFile = path.resolve(srcDir, file)
+        const destFile = path.resolve(destDir, file)
+        copy(srcFile, destFile)
+    }
+}
+
+function isEmpty(path) {
+    return fs.readdirSync(path).length === 0
+}
+
+function emptyDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return
+    }
+    for (const file of fs.readdirSync(dir)) {
+        const abs = path.resolve(dir, file)
+        // baseline is Node 12 so can't use rmSync :(
+        if (fs.lstatSync(abs).isDirectory()) {
+            emptyDir(abs)
+            fs.rmdirSync(abs)
+        } else {
+            fs.unlinkSync(abs)
+        }
+    }
+}
+
+/**
+ * @param {string | undefined} userAgent process.env.npm_config_user_agent
+ * @returns object | undefined
+ */
+function pkgFromUserAgent(userAgent) {
+    if (!userAgent) return undefined
+    const pkgSpec = userAgent.split(' ')[0]
+    const pkgSpecArr = pkgSpec.split('/')
+    return {
+        name: pkgSpecArr[0],
+        version: pkgSpecArr[1]
+    }
+}
+
+init().catch((e) => {
+    console.error(e)
+})

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "create-jwn-js",
+  "version": "1.0.1",
+  "license": "PRIVATE",
+  "author": "Webigorkiev",
+  "bin": {
+    "create-jwn-js": "index.js",
+    "cjj": "index.js"
+  },
+  "files": [
+    "index.js",
+    "template-*"
+  ],
+  "main": "index.js",
+  "scripts": {
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/webigorkiev",
+  "dependencies": {
+    "kolorist": "^1.5.0",
+    "margv": "^1.1.2",
+    "prompts": "^2.4.2"
+  }
+}

package/template-vite-node-ts/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+.DS_Store
+*.local
+connect.json
+.idea

package/template-vite-node-ts/connect-template.json

@@ -0,0 +1,36 @@
+{
+    "server": {
+        "development": {
+            "mode": "development",
+            "vite": {
+                "port": 3000
+            },
+            "port": 3001,
+            "host": "localhost"
+        },
+        "production": {
+            "mode": "production",
+            "port": 3000,
+            "host": "127.0.0.1",
+            "url": "http://127.0.0.1"
+        }
+    },
+    "db": {
+        "home": {
+            "engine": "mysql",
+            "host": "localhost",
+            "user": "",
+            "password": "",
+            "database": "",
+            "connectTimeout": 10000,
+            "acquireTimeout": 10000,
+            "connectionLimit": 2,
+            "charset": "utf8",
+            "compress": true,
+            "port": 3306,
+            "multipleStatements": true,
+            "namedPlaceholders": true,
+            "dateStrings": true
+        }
+    }
+}

package/template-vite-node-ts/docs/index.md

@@ -0,0 +1,31 @@
+# Template vite node js
+
+## Actions
+
+<table>
+    <tr>
+    <th>Method</th>    
+    <th>Action</th>    
+</tr>
+<tr>
+    <td>GET</td>
+    <td>view</td>
+</tr>
+<tr>
+    <td>POST</td>
+    <td>insert</td>
+</tr>
+<tr>
+    <td>PUT</td>
+    <td>update</td>
+</tr>
+<tr>
+    <td>DELETE</td>
+    <td>delete</td>
+</tr>
+</table>
+
+
+```/api/v1/clients/rest```
+
+

package/template-vite-node-ts/jest.config.ts

@@ -0,0 +1,37 @@
+export default {
+    moduleFileExtensions: [
+        "js",
+        "ts",
+        "json",
+        "vue",
+        "node"
+    ],
+    transform: {
+        "^.+\\.ts$": "ts-jest"
+    },
+    moduleNameMapper: {
+        "@/(.*)$": "<rootDir>/src/$1"
+    },
+    setupFiles: ["./src/scripts/jest.setup.ts"],
+    globalSetup: "./src/scripts/jest.global.setup.ts",
+    globalTeardown: "./src/scripts/jest.global.teardown.ts",
+    testTimeout: 35000,
+    globals: {
+        'ts-jest': {
+            tsconfig: './tsconfig.json',
+            diagnostics: false
+        }
+    },
+    testEnvironment: "jsdom",
+    maxWorkers: 2,
+    testMatch: [ "**/__its__/**/*.[jt]s?(x)", "**/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)" ],
+    testPathIgnorePatterns: ["<rootDir>/src/scripts",],
+    collectCoverageFrom: [
+        "**/src/**/*.{ts}",
+        "!**/src/**/*.d.ts",
+        "!**/src/**/index.ts",
+        "!**/src/scripts/**",
+        "!**/src/sql/**",
+        "!**/src/backend/server/web-routes/**",
+    ]
+};

package/template-vite-node-ts/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "vite-node-template",
+  "private": true,
+  "author": "webigorkiev",
+  "license": "PRIVATE",
+  "version": "1.0.1",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:serve": "vitepress serve docs"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.0.3",
+    "@types/memjs": "^1.2.4",
+    "@types/node": "^17.0.4",
+    "jest": "^27.4.5",
+    "ts-jest": "^27.1.2",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.4.4",
+    "vite": "^2.7.2",
+    "vitepress": "^0.20.9"
+  },
+  "dependencies": {
+    "@jwn-js/common": "^1.3.19",
+    "buildmsql": "^1.3.2",
+    "cross-fetch": "^3.1.4",
+    "easy-ash": "^1.1.5",
+    "margv": "^1.1.2",
+    "memjs": "^1.3.0"
+  }
+}

package/template-vite-node-ts/src/backend/server/helpers/createConfigServer.ts

@@ -0,0 +1,16 @@
+import margv from "margv";
+const args = margv();
+
+/**
+ * Config for server
+ * @param config
+ */
+export const createConfigServer = (config: Record<string, any>) => {
+    const configServer = process.env.NODE_ENV === "production" ? config.server.production : config.server.development;
+    configServer.port = +args.port + 1 || configServer.port;
+    configServer.host = args.host || configServer.host;
+    configServer.proxy =  `http://${configServer.host}:${configServer.port}`;
+    configServer.vitePort = config.server.development.vite.port;
+
+    return configServer;
+}

package/template-vite-node-ts/src/backend/server/helpers/createMariadb.ts

@@ -0,0 +1,12 @@
+import {Query} from "buildmsql";
+
+/**
+ * Create mariadb pool
+ * @param config
+ */
+export const createMariadb = (config: Record<string, any>) => {
+    const home = new Query({debug: process.env.NODE_ENV === "production" ? 0 : 1});
+    const homePool = home.createPool(config.db.home);
+
+    return {homePool, home};
+}

package/template-vite-node-ts/src/backend/server/helpers/createMemcached.ts

@@ -0,0 +1,15 @@
+import memjs from "memjs";
+import {Memcached} from "@jwn-js/common";
+
+export const createMemcached = () => {
+    const memcachedClient = memjs.Client.create("127.0.0.1:11211", {
+        timeout: 1,
+        conntimeout: 1,
+        logger: {
+            log: () => {}
+        }
+    });
+    const memcached =  new Memcached(memcachedClient);
+
+    return {memcachedClient, memcached};
+}

package/template-vite-node-ts/src/backend/server/helpers/nameFormaters.ts

@@ -0,0 +1,9 @@
+export const upperCaseFirstLetter =  (str: string): string => str.charAt(0).toUpperCase() + str.slice(1);
+export const controllerFormat = (schema: string) => schema
+    .split('-')
+    .map(v => upperCaseFirstLetter(v))
+    .join('');
+export const subactionFormat = (method: string) => method
+    .split('-')
+    .map((v, i) => i > 0 ? upperCaseFirstLetter(v) : v)
+    .join('');

package/template-vite-node-ts/src/backend/server/index.ts

@@ -0,0 +1,53 @@
+import {Server, helpers, Web, OptionsWeb} from "@jwn-js/common";
+import {createConfigServer} from "./helpers/createConfigServer";
+import {subactionFormat, controllerFormat} from "./helpers/nameFormaters";
+import {schema} from "./site-schema";
+import {webRoutes} from "./web-routes";
+import {createMariadb} from "./helpers/createMariadb";
+import {createMemcached} from "./helpers/createMemcached";
+declare var process: any;
+
+const {readConfigSync} = helpers;
+process.server = process.server || {};
+let memcachedClient, memcached, home;
+const config = readConfigSync("./connect.json");
+const configServer = createConfigServer(config);
+
+if(process.env.NODE_ENV === "production") {
+    ({home} = createMariadb(config));
+    ({memcachedClient, memcached} = createMemcached());
+}
+const webOptions: OptionsWeb = {
+    routes: webRoutes,
+    config,
+    db: process.server.db || {
+        home
+    },
+    memcached: process.server.memcached || memcached,
+    schema
+}
+
+process.server.app = new Server({
+    ...configServer,
+    routes: [
+        {
+            method: "any",
+            pattern: "/api/v1/*",
+            handler: (res, req) => {
+                const url = req.getUrl();
+                const method = req.getMethod().toLowerCase();
+                const parts = url
+                    .split('/')
+                    .slice(3);
+                const last = parts.pop() as string;
+                const subaction = subactionFormat(last === "rest" ? `${method}-${last}`: last);
+                const partsFormated = parts.map((v:string) => controllerFormat(v));
+                const controller = `Api/v1/${partsFormated.join("/")}`;
+
+                return new Web(res, req, webOptions).request({controller, subaction});
+            }
+        },
+    ]
+})
+    .app()
+    .listen();

package/template-vite-node-ts/src/backend/server/site-schema.ts

@@ -0,0 +1,28 @@
+import {Schema} from "@jwn-js/common";
+
+export const schema: Schema = {
+    actions: [
+        {
+            id: 1,
+            name: "view"
+        }
+    ],
+    controllers: [
+        {
+            id: 1,
+            name: "Api/v1/Clients",
+            subactions: [
+                {
+                    id: 1,
+                    name: "index",
+                    action: "view"
+                },
+                {
+                    id: 2,
+                    name: "getRest",
+                    action: "view"
+                }
+            ]
+        }
+    ]
+}

package/template-vite-node-ts/src/backend/server/web-routes/index.ts

@@ -0,0 +1,9 @@
+import {Route} from "@jwn-js/common";
+
+export const webRoutes: Array<Route> = [
+    {
+        method: "any",
+        name: "Api/v1/Clients",
+        component: () => import("@/backend/views/Api/v1/Clients/ClientsController")
+    },
+];

package/template-vite-node-ts/src/backend/views/Api/v1/Clients/ClientsController.ts

@@ -0,0 +1,16 @@
+import {Controller, http} from "@jwn-js/common";
+
+/**
+ * /api/v1/clients/index
+ */
+export default class ClientsController extends Controller {
+
+    @http()
+    async index() {
+    }
+
+    @http()
+    async getRest() {
+    }
+
+}

package/template-vite-node-ts/src/backend/views/Api/v1/Clients/__its__/clients.spec.ts

@@ -0,0 +1,9 @@
+import {fetch, apiUrl} from "@/scripts/jest.setup";
+
+describe("Api/v1/Clients", () => {
+    const url = new URL(apiUrl + "/api/v1/clients/index");
+    it("request GET /api/v1/clients/index", async() => {
+        const response = await fetch(url.toString());
+        expect(response.ok).toEqual(true);
+    })
+});

package/template-vite-node-ts/src/scripts/jest.global.setup.ts

@@ -0,0 +1,12 @@
+import {createServer, ViteDevServer} from "vite";
+import {Query, Connection} from "buildmsql";
+
+declare global {
+    var server: ViteDevServer;
+}
+
+export default async(config: Record<string, any>) => {
+    global.server = await createServer();
+    await global.server.listen();
+    await new Promise(resolve => setTimeout(resolve, 500));
+}

package/template-vite-node-ts/src/scripts/jest.global.teardown.ts

@@ -0,0 +1,9 @@
+import {ViteDevServer} from "vite";
+
+declare global {
+    var server: ViteDevServer;
+}
+
+export default async() => {
+    await global.server.close();
+}

package/template-vite-node-ts/src/scripts/jest.setup.ts

@@ -0,0 +1,16 @@
+import crossFetch from "cross-fetch";
+import connect from "../../connect.json"
+
+const apiUrl = `http://${connect.server.development.host}:${connect.server.development.vite.port}`;
+const defaultHeaders = {
+    headers: {
+        "user-agent": "fetch-tests",
+        "content-type": "application/json"
+    }
+}
+const fetch = async(
+    input: RequestInfo,
+    init: RequestInit = {}
+) => crossFetch(input, Object.assign({}, defaultHeaders, init));
+
+export {fetch, apiUrl};

package/template-vite-node-ts/tsconfig.json

@@ -0,0 +1,47 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true,
+    "noImplicitThis": true,
+    "jsx": "preserve",
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": true,
+    "noImplicitAny": true,
+    "strictFunctionTypes": false,
+    "skipLibCheck": true,
+    "strictPropertyInitialization": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "lib": [
+      "esnext",
+      "dom"
+    ],
+    "types": [
+      "vite/client",
+      "@types/jest",
+      "node",
+      "jest-environment-puppeteer"
+    ],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.d.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/template-vite-node-ts/vite.config.ts

@@ -0,0 +1,84 @@
+import path from "path";
+import {build, defineConfig, mergeConfig, Plugin, ResolvedConfig} from "vite";
+import fetch from "cross-fetch";
+import config from "./connect.json";
+import {createConfigServer} from "./src/backend/server/helpers/createConfigServer";
+import {createMemcached} from "./src/backend/server/helpers/createMemcached";
+import {createMariadb} from "./src/backend/server/helpers/createMariadb";
+
+declare var process: any;
+interface Options {
+    entry: string
+}
+
+const cnf = createConfigServer(config);
+const {memcachedClient, memcached} = createMemcached();
+const {home, homePool} = createMariadb(config);
+process.server = {
+    db: {home},
+    memcached
+};
+
+const node = (opt: Options): Plugin => {
+
+    return {
+        name: "vite-node-js",
+        async configureServer(server) {
+
+            return () => server.middlewares.use(
+                async (req, res, next) => {
+                    await server.ssrLoadModule(path.join(server.config.root, opt.entry));
+                    res.end();
+                });
+        },
+        async configResolved(config:ResolvedConfig) {
+            if(config.command === "build") {
+
+                // @ts-ignore
+                if(!config.build.isBuild) {
+                    await build(mergeConfig({
+                        build: {
+                            isBuild: true,
+                            outDir: path.resolve(config.root, `dist`),
+                            ssr: path.join(config.root, opt.entry),
+                        }
+                    }, {}));
+                    process.exit(0);
+                }
+            } else {
+                setTimeout(() => fetch(`http://${cnf.host}:${cnf.vitePort}/start-server`), 100);
+            }
+        },
+        async closeBundle() {
+            await memcachedClient.close();
+            await homePool.end();
+            process.server.app && await process.server.app.close();
+        }
+    }
+}
+
+export default defineConfig({
+    resolve: {
+        alias: [
+            {
+                find: /@\/(.*)/,
+                replacement: path.resolve("./src") + "/$1"
+            }
+        ],
+    },
+    server: {
+        host: cnf.host,
+        port: config.server.development.vite.port,
+        proxy: {
+            "^/api/v1/.*": `http://${cnf.host}:${cnf.port}`
+        },
+    },
+    optimizeDeps: {
+      include:[]
+    },
+    plugins: [
+        node({
+            entry: "/src/backend/server/index.ts"
+        })
+    ]
+});