vdev/dist/psql.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.pgStatus = exports.pgTest = exports.psqlCommand = exports.psqlExport = exports.psqlImport = void 0;
const fs = __importStar(require("fs-extra"));
const p_spawn_1 = require("p-spawn");
const defaultPsqlOptions = {
    toConsole: true
};
// NOTE: for now, ignore pgOpts.pwd
async function psqlImport(pgOpts, filePaths) {
    pgOpts = { ...defaultPsqlOptions, ...pgOpts };
    const items = [];
    if (typeof filePaths === "string") {
        filePaths = [filePaths];
    }
    for (let file of filePaths) {
        const item = { file };
        const { stdout, stderr } = await execPsql(pgOpts, ["-f", file]);
        item.stdout = stdout;
        item.stderr = stderr;
        items.push(item);
        if (stderr) {
            const err = new Error(`psqlImport ERROR for file ${file}:\n${item.stderr}`);
            err.items = items;
            throw err;
        }
    }
    return items;
}
exports.psqlImport = psqlImport;
// pgdump with no-owner, no-acl
async function psqlExport(pgOpts, filepath) {
    var defaultArgs = ["--no-owner", "--no-acl"];
    var cmd = "pg_dump";
    const { args, env } = buildPgArgs(pgOpts);
    args.push.apply(args, defaultArgs);
    var fStream = fs.createWriteStream(filepath, { flags: 'w' });
    console.log("will execute >> " + cmd + " " + args.join(" ") + "\n\t into " + filepath);
    await p_spawn_1.spawn(cmd, args, {
        env,
        onStdout: (data) => {
            fStream.write(data);
        }
    });
}
exports.psqlExport = psqlExport;
async function psqlCommand(pgOpts, command) {
    const { stdout, stderr } = await execPsql({ ...pgOpts, toConsole: true }, [`--command=${command}`]);
    if (stderr) {
        throw Error(`ERROR - cannot psqlCommand "${command}" because ${stderr}`);
    }
    return stdout;
}
exports.psqlCommand = psqlCommand;
async function pgTest(pgOpts) {
    const status = await pgStatus(pgOpts);
    if (!status.accepting) {
        return { success: false, message: status.message };
    }
    // --command="SELECT version();
    // var args = buildPgArgs(pgOpts);
    const { args, env } = buildPgArgs(pgOpts);
    args.push("--command=SELECT version()");
    const p = await p_spawn_1.spawn('psql', args, { env, capture: ['stdout', 'stderr'], ignoreFail: true });
    if (p.code === 0) {
        return { success: true, message: p.stdout.trim() };
    }
    else {
        const r = { success: false, message: p.stdout };
        if (p.stderr) {
            r.err = p.stderr.trim();
        }
        return r;
    }
}
exports.pgTest = pgTest;
/** Return the status of a pg database process (without the database) */
async function pgStatus(pgOpts) {
    const { args, env } = buildPgArgs(pgOpts);
    //args.push('-q'); // for the quiet mode, we just need to result code
    const p = await p_spawn_1.spawn('pg_isready', args, { env, ignoreFail: true, capture: ['stdout', 'stderr'] });
    const code = p.code;
    const message = p.stdout.trim();
    const accepting = (0 === p.code) ? true : false;
    return { accepting, message, code };
}
exports.pgStatus = pgStatus;
// --------- /Utils public API --------- //
// --------- Private Utils --------- //
async function execPsql(pgOpts, args) {
    const { args: baseArgs, env } = buildPgArgs(pgOpts);
    // add the args at the end
    args = [...baseArgs, ...args];
    const spawnOptions = buildSpawnOptions(pgOpts);
    const spawnResult = await p_spawn_1.spawn('psql', args, { env, ...spawnOptions, ignoreFail: true });
    let { stdout, stderr } = spawnResult;
    if (stderr) {
        const err = stderr.trim();
        let itemErr = null;
        for (const line of err.split('\n')) {
            if (!line.includes("NOTICE:")) {
                itemErr = (itemErr == null) ? line : `${itemErr}\n${line}`;
            }
        }
        stderr = itemErr !== null && itemErr !== void 0 ? itemErr : undefined;
    }
    return { stdout: stdout !== null && stdout !== void 0 ? stdout : '', stderr: stderr !== null && stderr !== void 0 ? stderr : '' };
}
function buildSpawnOptions(pgOpts) {
    let spawnOptions = { capture: ['stdout', 'stderr'] };
    if (pgOpts.toConsole) {
        spawnOptions.toConsole = true;
    }
    return spawnOptions;
}
// private: Build a cmd line argument list from a pgOpts {user, db[, pwd][, host][, port: 5432]} and make it an command line arguments
function buildPgArgs(pgOpts) {
    var args = [];
    if (pgOpts.user) {
        args.push("-U", pgOpts.user);
    }
    if (pgOpts.database) {
        args.push("-d", pgOpts.database);
    }
    if (pgOpts.host) {
        args.push("-h", pgOpts.host);
    }
    if (pgOpts.port) {
        args.push("-p", pgOpts.port);
    }
    const env = (pgOpts.password == null) ? process.env : { ...process.env, PGPASSWORD: pgOpts.password };
    return { args, env };
}
// --------- /Private Utils --------- //