@scmbwis/bpg-gen 0.1.6

package/dist/utils/pg.utils.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueAsSql = valueAsSql;
+/* import { Client, Pool, PoolClient, PoolConfig, QueryConfig, QueryResult, types } from "pg"
+import { Env } from "../env"
+
+require("dotenv").config()
+export const getQueryAsText = (text: string, values?: any[]): string => {
+    let returnMe = text
+    if (values) {
+        // need to do in reverse or $2 will replace start of $20
+        for (let i = values.length; i > 0; i--) {
+            const val = values[i - 1]
+            const replaceMe = new RegExp(`[$]${i}\\b`, "g")
+            returnMe = returnMe.replace(replaceMe, valueAsSql(val))
+        }
+    }
+    return returnMe
+}
+*/
+function valueAsSql(val) {
+    let sqlVal;
+    if (val == null || val == undefined) {
+        sqlVal = "null";
+    }
+    else {
+        sqlVal = val.toString();
+        if (typeof (val) == "string") {
+            sqlVal = `'${sqlVal}'`;
+        }
+        else if (val instanceof Date) {
+            const dateVal = val;
+            sqlVal = `'${dateVal.getFullYear()}-${dateVal.getMonth() + 1}-${dateVal.getDate()} ${dateVal.getHours()}:${dateVal.getMinutes()}:${dateVal.getSeconds()}'`;
+            //'2020-06-22 19:10:25-07'
+        }
+        else if (typeof (val) == "object") {
+            sqlVal = `'${JSON.stringify(val)}'`;
+        }
+    }
+    return sqlVal;
+}
+/*
+export async function executeQuery<T>(query: QueryConfig, inClient?: PoolClient): Promise<T[]>
+export async function executeQuery<T>(text: string, values?: any[]): Promise<T[]>
+export async function executeQuery<T>(query: unknown, valuesOrClient?: any[] | PoolClient): Promise<T[]> {
+    let querySpec: QueryConfig
+    let client: PoolClient | Client | undefined = undefined
+    if (typeof query === 'string') {
+        if (valuesOrClient != undefined && !Array.isArray(valuesOrClient)) {
+            throw new Error("can't use pool client with text query")
+        }
+        querySpec = {
+            text: query,
+            values: valuesOrClient
+        }
+    }
+    else {
+        if (valuesOrClient != undefined && Array.isArray(valuesOrClient)) {
+            throw new Error("can't use values array with query config")
+        }
+        client = valuesOrClient
+        querySpec = query as QueryConfig
+    }
+    try {
+        let externalClient = true
+        if (client == undefined) {
+            externalClient = false
+            client = new Client(Env.pg)
+            await client.connect()
+        }
+        //	console.log(getQueryAsText(querySpec.text, querySpec.values))
+
+        const result = await client.query(querySpec)
+        if (!externalClient) {
+            const cc = client as Client
+            cc.end()
+        }
+        return result.rows
+    } catch (err) {
+        console.log(getQueryAsText(querySpec.text, querySpec.values))
+        console.log(err)
+        throw err
+    }
+    finally {
+
+    }
+
+    return []
+}
+export async function executeQueryForOneDef<T>(query: QueryConfig): Promise<T>
+export async function executeQueryForOneDef<T>(text: string, values?: any[]): Promise<T>
+export async function executeQueryForOneDef<T>(query: unknown, values?: any[]): Promise<T> {
+    let querySpec: QueryConfig
+    if (typeof query === 'string') {
+        querySpec = {
+            text: query,
+            values
+        }
+    }
+    else {
+        querySpec = query as QueryConfig
+    }
+    const result = await executeQueryForOne<T>(querySpec)
+    if (!result) {
+        throw new Error("query resulted in an undefined result: " + getQueryAsText(querySpec.text, querySpec.values))
+    }
+    return result
+}
+export async function executeQueryForOne<T>(query: QueryConfig): Promise<T | undefined>
+export async function executeQueryForOne<T>(query: string, values?: any[]): Promise<T | undefined>
+export async function executeQueryForOne<T>(query: unknown, values?: any[]): Promise<T | undefined> {
+    let querySpec: QueryConfig
+    if (typeof query === 'string') {
+        querySpec = {
+            text: query,
+            values
+        }
+    }
+    else {
+        querySpec = query as QueryConfig
+    }
+
+    const rows = await executeQuery<T>(querySpec)
+    if (rows.length == 0) {
+        return
+    }
+    if (rows.length >= 1) {
+        return rows[0]
+    }
+}
+
+export interface DbConfig extends PoolConfig {
+    host: string;
+    database: string;
+    user: string;
+    password: string;
+    port?: number;
+}
+
+export interface PgConnection {
+    pool: Pool;
+    config: DbConfig;
+}
+export interface PgResultSet {
+    couldConnect: boolean;
+    hadQueryErrors: boolean;
+    queries: PgResult[];
+    connectionError?: Error;
+}
+export interface PgResult {
+    success: boolean;
+    query: QueryConfig;
+    error?: any;
+    results?: QueryResult<any>;// only undefined if error
+}
+export const getConn = (dbConfig: DbConfig): PgConnection => {
+    const config: DbConfig = {
+        ...dbConfig,
+        max: 20,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 2000
+    };
+    const pool = new Pool(config);
+    const conn = {
+        pool: pool,
+        config: config
+    }
+    return conn;
+}
+export const runQueries = async (conn: PgConnection, queries: string[] | QueryConfig[] | string | QueryConfig, breakOnError: boolean = true): Promise<PgResultSet> => {
+    const results: PgResultSet = {
+        queries: [],
+        couldConnect: false,
+        hadQueryErrors: false
+    }
+    let client: PoolClient | undefined;
+    // turn the queries into same format - QueryConfigs can be paremerterised
+    // https://node-postgres.com/features/queries
+    const queryArray: QueryConfig[] = [];
+    if (Array.isArray(queries)) {
+        for (let i = 0; i < queries.length; i++) {
+            const query = queries[i];
+            if (typeof query === 'string' || query instanceof String) {
+                queryArray.push({ text: query as string });
+            }
+            else {
+                queryArray.push(query as QueryConfig);
+            }
+        }
+    }
+    else {
+        const query = queries;
+        if (typeof query === 'string' || query instanceof String) {
+            queryArray.push({ text: query as string });
+        }
+        else {
+            queryArray.push(query as QueryConfig);
+        }
+    }
+    // run them
+    try {
+        client = await conn.pool.connect();
+        results.couldConnect = true;
+        for (let i = 0; i < queryArray.length && !(breakOnError && results.hadQueryErrors); i++) {
+            const query = queryArray[i];
+            try {
+                results.queries.push({
+                    query: query,
+                    success: true,
+                    results: await client.query(query)
+                });
+            }
+            catch (err) {
+                results.queries.push({
+                    query: query,
+                    success: false,
+                    error: err
+                });
+                console.log(query.text);
+                results.hadQueryErrors = true;
+            }
+        }
+    }
+    catch (err: any) {
+        results.connectionError = err;
+    }
+    finally {
+        if (client) client.release();
+    }
+    return results;
+}
+
+export const canConnect = async (conn: PgConnection): Promise<boolean> => {
+    const results = await runQueries(conn, "SELECT * FROM NOW()");
+    return results.couldConnect && !results.hadQueryErrors;
+}
+export const validateConnection = async (conn: PgConnection): Promise<void> => {
+    const results = await runQueries(conn, "SELECT * FROM NOW()");
+    if (results.hadQueryErrors) {
+        throw new Error(`db connect issue: ${results.connectionError?.message}`);
+    }
+}
+export const pgToJson = {
+    entityId: (pgVal: string): number => {
+        if (pgVal == null) return 0;
+        return parseInt(pgVal.toString());
+    },
+    string: (pgVal: string): string => {
+        if (pgVal == null) return "";
+        return pgVal.replace(/''/g, "'");
+    },
+    object: (pgVal: object): object => {
+        if (pgVal == null) return {};
+        return pgVal;
+    },
+    complexProp: (pgVal: object): undefined => {
+        throw new Error("complex prop shouldn't be translated");
+    },
+    wholeNum: (pgVal: string): number => {
+        if (pgVal == null) return 0;
+        return parseInt(pgVal.toString());
+    },
+    realNum: (pgVal: string): number => {
+        if (pgVal == null) return 0;
+        return parseFloat(pgVal.toString());
+    },
+    timestamp: (pgVal: string): Date => {
+        return new Date(pgVal);
+    },
+    bool: (pgVal: boolean): boolean => {
+        if (pgVal == null) return false;
+        return pgVal;
+    }
+}
+export function getDb(env: NodeJS.ProcessEnv, prefix: string = ''): DbConfig {
+    const config: DbConfig = {
+        host: env[`${prefix}DB_HOST`] || 'localhost',
+        database: env[`${prefix}DB_DATABASE`] || '',
+        user: env[`${prefix}DB_USER`] || '',
+        password: env[`${prefix}DB_PASS_SECRET`] || ''
+    }
+    if (env[`${prefix}DB_PORT`]) {
+        config.port = parseInt(env[`${prefix}DB_PORT`] || 'NaN');
+    }
+    return config;
+}
+export async function createSchema(schema: string, comment: string) {
+    const user = Env.pg.user.split("@")[0]
+    await executeQuery(`
+    CREATE SCHEMA ${schema}
+            AUTHORIZATION ${user};
+    
+    COMMENT ON SCHEMA public
+            IS '${comment}';
+    
+    GRANT ALL ON SCHEMA ${schema} TO PUBLIC;
+    
+    GRANT ALL ON SCHEMA ${schema} TO ${user};
+    `)
+}
+     */ 
+//# sourceMappingURL=pg.utils.js.map

package/dist/utils/pg.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.utils.js","sourceRoot":"","sources":["../../lib/utils/pg.utils.ts"],"names":[],"mappings":";;AAiBA,gCAqBC;AAtCD;;;;;;;;;;;;;;;;EAgBE;AACF,SAAgB,UAAU,CAAC,GAAQ;IAClC,IAAI,MAAc,CAAA;IAClB,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,SAAS,EAAE,CAAC;QACrC,MAAM,GAAG,MAAM,CAAA;IAChB,CAAC;SACI,CAAC;QACL,MAAM,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAA;QACvB,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,QAAQ,EAAE,CAAC;YAC9B,MAAM,GAAG,IAAI,MAAM,GAAG,CAAA;QACvB,CAAC;aACI,IAAI,GAAG,YAAY,IAAI,EAAE,CAAC;YAC9B,MAAM,OAAO,GAAG,GAAW,CAAA;YAC3B,MAAM,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,IAAI,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,IAAI,OAAO,CAAC,QAAQ,EAAE,IAAI,OAAO,CAAC,UAAU,EAAE,IAAI,OAAO,CAAC,UAAU,EAAE,GAAG,CAAA;YAC1J,0BAA0B;QAC3B,CAAC;aACI,IAAG,OAAO,CAAC,GAAG,CAAC,IAAI,QAAQ,EAAE,CAAC;YAClC,MAAM,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAA;QACpC,CAAC;IAEF,CAAC;IACD,OAAO,MAAM,CAAA;AACd,CAAC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmQI"}

package/dist/utils/writingutils.d.ts

@@ -0,0 +1,12 @@
+export declare function writeDirsAndFiles(dir: WriteMeDir): Promise<void>;
+export type WriteMe = WriteMeDir | WriteMeFile;
+export type WriteMeFile = {
+    type: "file";
+    outpath: string;
+    content: string;
+};
+export type WriteMeDir = {
+    type: "dir";
+    outpath: string;
+    children: WriteMe[];
+};

package/dist/utils/writingutils.js

@@ -0,0 +1,63 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 });
+exports.writeDirsAndFiles = writeDirsAndFiles;
+const genutils_1 = require("./genutils");
+const fs = __importStar(require("fs/promises"));
+function writeDirsAndFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield (0, genutils_1.exists)(dir.outpath))) {
+            yield (0, genutils_1.mkDir)(dir.outpath);
+        }
+        for (let child of dir.children) {
+            if (child.type === "dir") {
+                yield writeDirsAndFiles(child);
+            }
+            else if (child.type === "file") {
+                yield fs.writeFile(child.outpath, child.content);
+            }
+        }
+    });
+}
+//# sourceMappingURL=writingutils.js.map

package/dist/utils/writingutils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writingutils.js","sourceRoot":"","sources":["../../lib/utils/writingutils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,8CAYC;AAfD,yCAA0C;AAC1C,gDAAiC;AAEjC,SAAsB,iBAAiB,CAAC,GAAe;;QACnD,IAAI,CAAC,CAAC,MAAM,IAAA,iBAAM,EAAC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAA,gBAAK,EAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC5B,CAAC;QACD,KAAK,IAAI,KAAK,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;YAC7B,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;gBACvB,MAAM,iBAAiB,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC;iBACI,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBAC7B,MAAM,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;YACpD,CAAC;QACL,CAAC;IACL,CAAC;CAAA"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@scmbwis/bpg-gen",
+  "version": "0.1.6",
+  "description": "Local project code generator CLI",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "node ./scripts/clean-dist.mjs",
+    "build": "npm run clean && tsc",
+    "typecheck": "tsc --noEmit",
+    "test:hardening": "npm run build && node ./scripts/hardening-check.mjs",
+    "prepack": "npm run build"
+  },
+  "author": "",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@faker-js/faker": "^10.1.0",
+    "dotenv": "^17.2.3",
+    "pluralize": "^8.0.0",
+    "tsx": "^4.20.6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@types/pluralize": "^0.0.33"
+  },
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "bpg-gen": "./dist/cli/index.js",
+    "bgen": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scmbwis/pg-express-toolbox.git",
+    "directory": "bpg-gen"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}