@zuplo/cli 1.4.0

package/README.md

@@ -0,0 +1 @@
+# Zuplo CLI

package/dist/cli.js

@@ -0,0 +1,15 @@
+import * as dotenv from "dotenv";
+dotenv.config();
+import { hideBin } from "yargs/helpers";
+import yargs from "yargs/yargs";
+import deploy from "./cmds/deploy.js";
+import test from "./cmds/test.js";
+void yargs(hideBin(process.argv))
+    .env("ZUPLO")
+    .version(false)
+    .command(deploy)
+    .command(test)
+    .demandCommand()
+    .strictCommands()
+    .help().argv;
+//# sourceMappingURL=cli.js.map

package/dist/cmds/deploy.js

@@ -0,0 +1,30 @@
+import { validDeployDirectoryValidator } from "../common/validators/file-system-validator.js";
+import { YargsChecker } from "../common/validators/lib.js";
+import { deploy } from "../deploy/handler.js";
+export default {
+    desc: "Deploys current Git branch of the current directory.",
+    command: "deploy [--apiKey]",
+    builder: (yargs) => {
+        return yargs
+            .option("apiKey", {
+            type: "string",
+            describe: "The API Key from Zuplo",
+            envVar: "API_KEY",
+        })
+            .demandOption(["apiKey"])
+            .option("dir", {
+            type: "string",
+            describe: "The directory containing your zup",
+            default: ".",
+            normalize: true,
+            hidden: true,
+        })
+            .check(async (argv) => {
+            return await new YargsChecker(validDeployDirectoryValidator).check(argv.dir);
+        });
+    },
+    handler: async (argv) => {
+        await deploy(argv);
+    },
+};
+//# sourceMappingURL=deploy.js.map

package/dist/cmds/test.js

@@ -0,0 +1,28 @@
+import { validTestDirectoryValidator } from "../common/validators/file-system-validator.js";
+import { YargsChecker } from "../common/validators/lib.js";
+import { test } from "../test/handler.js";
+export default {
+    desc: "Runs the tests under /tests against the [endpoint]",
+    command: "test [endpoint]",
+    builder: (yargs) => {
+        return yargs
+            .positional("endpoint", {
+            type: "string",
+            describe: "The URL of the zup to test against",
+        })
+            .option("dir", {
+            type: "string",
+            describe: "The directory containing your zup",
+            default: ".",
+            normalize: true,
+            hidden: true,
+        })
+            .check(async (argv) => {
+            return await new YargsChecker(validTestDirectoryValidator).check(argv.dir);
+        });
+    },
+    handler: async (argv) => {
+        await test(argv);
+    },
+};
+//# sourceMappingURL=test.js.map

package/dist/common/alias.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=alias.js.map

package/dist/common/constants.js

@@ -0,0 +1,4 @@
+export const DEPLOYER_METADATA_FILE = "deployer.json";
+export const TEST_IN_FOLDER = "tests";
+export const TEST_OUT_FOLDER = ".zuplo/__tests__";
+//# sourceMappingURL=constants.js.map

package/dist/common/logger.js

@@ -0,0 +1,8 @@
+import * as Pino from "pino";
+export const logger = Pino.pino({
+    level: process.env.LOG_LEVEL || "warn",
+    transport: {
+        target: "pino-pretty",
+    },
+});
+//# sourceMappingURL=logger.js.map

package/dist/common/output.js

@@ -0,0 +1,4 @@
+export function printToConsole(message, ...optionalParams) {
+    console.log(message, ...optionalParams);
+}
+//# sourceMappingURL=output.js.map

package/dist/common/settings.js

@@ -0,0 +1,8 @@
+class Settings {
+    get ZUPLO_DEVELOPER_API_ENDPOINT() {
+        return process.env.ZUPLO_DEVELOPER_API_ENDPOINT ?? "https://dev.zuplo.com";
+    }
+}
+const settings = new Settings();
+export default settings;
+//# sourceMappingURL=settings.js.map

package/dist/common/validators/file-system-validator.js

@@ -0,0 +1,82 @@
+import fg from "fast-glob";
+import { existsSync } from "node:fs";
+import { simpleGit } from "simple-git";
+import { TEST_IN_FOLDER } from "../constants.js";
+import { CompositeValidator } from "./lib.js";
+export class NotAGitRepoError extends Error {
+    constructor() {
+        super("Invalid directory: The current directory is not a Git repository.");
+        Object.setPrototypeOf(this, NotAGitRepoError.prototype);
+    }
+}
+export class NotAZuploProject extends Error {
+    constructor() {
+        super("Invalid directory: The current directory is not a Zuplo project.");
+        Object.setPrototypeOf(this, NotAZuploProject.prototype);
+    }
+}
+export class ZuploProjectMissingTests extends Error {
+    constructor() {
+        super("Invalid directory: The current directory does not contain any tests (*.test.ts) in the /tests folder. Create a at least one test of the form some-name.test.ts");
+        Object.setPrototypeOf(this, ZuploProjectMissingTests.prototype);
+    }
+}
+export class GitVersionControlValidator {
+    async validate(dir) {
+        try {
+            await simpleGit({ baseDir: dir }).status();
+            return { ok: true };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: new NotAGitRepoError(),
+            };
+        }
+    }
+}
+export class ZuploProjectValidator {
+    async validate(dir) {
+        try {
+            if (existsSync(`${dir}/config/routes.json`)) {
+                return { ok: true };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: new NotAZuploProject(),
+                };
+            }
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err,
+            };
+        }
+    }
+}
+export class ZuploProjectHasTestsValidator {
+    async validate(dir) {
+        try {
+            if (fg.sync(`${dir}/${TEST_IN_FOLDER}/**/*.test.ts`).length >= 1) {
+                return { ok: true };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: new ZuploProjectMissingTests(),
+                };
+            }
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err,
+            };
+        }
+    }
+}
+export const validDeployDirectoryValidator = new CompositeValidator(new GitVersionControlValidator(), new ZuploProjectValidator());
+export const validTestDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new ZuploProjectHasTestsValidator());
+//# sourceMappingURL=file-system-validator.js.map

package/dist/common/validators/lib.js

@@ -0,0 +1,31 @@
+export class CompositeValidator {
+    validators = new Array();
+    constructor(...validators) {
+        this.validators = validators;
+    }
+    async validate(what) {
+        for (const rule of this.validators) {
+            const result = await rule.validate(what);
+            if (!result.ok) {
+                return result;
+            }
+        }
+        return { ok: true };
+    }
+}
+export class YargsChecker {
+    validator;
+    constructor(validator) {
+        this.validator = validator;
+    }
+    async check(what) {
+        const result = await this.validator.validate(what);
+        if (!result.ok) {
+            return result.error.message;
+        }
+        else {
+            return true;
+        }
+    }
+}
+//# sourceMappingURL=lib.js.map

package/dist/deploy/archive.js

@@ -0,0 +1,93 @@
+import ignore from "ignore";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { simpleGit } from "simple-git";
+import * as tar from "tar";
+import * as temp from "temp";
+import { DEPLOYER_METADATA_FILE } from "../common/constants.js";
+import { logger } from "../common/logger.js";
+export async function archive(dir) {
+    const tarball = temp.path({ suffix: ".tar.gz" });
+    const ignoreFn = createIgnoreFunction(dir);
+    const normalizedDir = join(relative(process.cwd(), dir));
+    const metadata = await prepareDeployerMetadata(dir);
+    await tar.create({
+        gzip: true,
+        file: tarball,
+        filter: (path, stat) => {
+            const stats = stat;
+            const normalizedPath = stats.isDirectory()
+                ? join(relative(process.cwd(), path), sep)
+                : join(relative(process.cwd(), path));
+            if (normalizedPath === "/") {
+                return true;
+            }
+            if (normalizedPath === ".zuplo/") {
+                return true;
+            }
+            if (normalizedPath === `.zuplo/${DEPLOYER_METADATA_FILE}`) {
+                return true;
+            }
+            const result = ignoreFn.ignores(normalizedPath);
+            logger.trace(`${normalizedPath} ignored: ${result}`);
+            return !result;
+        },
+    }, [normalizedDir]);
+    return {
+        tarball,
+        metadata,
+    };
+}
+function createIgnoreFunction(normalizedDir) {
+    const baseIgnore = ignore().add(".git/");
+    if (existsSync(`${normalizedDir}/.zupignore`)) {
+        const zupignorePath = `${normalizedDir}/.zupignore`;
+        logger.debug(`Using ${zupignorePath} to filter out files`);
+        return baseIgnore.add(readFileSync(zupignorePath).toString());
+    }
+    else if (existsSync(`${normalizedDir}/.gitignore`)) {
+        const gitignorePath = `${normalizedDir}/.gitignore`;
+        logger.debug(`Using ${gitignorePath} to filter out files`);
+        return baseIgnore.add(readFileSync(gitignorePath).toString());
+    }
+    else {
+        logger.debug("Didn't find a .gitignore or .zupignore file. Defaulting to ignoring .git and node_modules.");
+        return baseIgnore.add("node_modules/");
+    }
+}
+async function prepareDeployerMetadata(dir) {
+    const metadata = await generateMetadata(dir);
+    await writeGeneratedMetadata(dir, metadata);
+    return metadata;
+}
+async function generateMetadata(dir) {
+    const git = simpleGit({ baseDir: dir });
+    const status = await git.status();
+    if (!status.current) {
+        throw new Error("Invalid state: Directory is in detached head state.");
+    }
+    const branch = status.current.trim();
+    const sha = (await git.revparse(["HEAD"])).trim();
+    const repoUrl = (await git.listRemote(["--get-url"])).trim();
+    return {
+        branch,
+        repoUrl,
+        sha,
+    };
+}
+async function writeGeneratedMetadata(dir, metadata) {
+    try {
+        mkdirSync(`${dir}/.zuplo`);
+    }
+    catch (err) {
+        if (err.code === "EEXIST") {
+        }
+        else {
+            throw err;
+        }
+    }
+    await writeFileSync(`${dir}/.zuplo/${DEPLOYER_METADATA_FILE}`, JSON.stringify(metadata, null, 2), {
+        flag: "w",
+    });
+}
+//# sourceMappingURL=archive.js.map

package/dist/deploy/file-upload.js

@@ -0,0 +1,14 @@
+import { readFileSync, statSync } from "node:fs";
+export async function upload(tarballPath, url) {
+    const stats = statSync(tarballPath);
+    const fileSizeInBytes = stats.size;
+    const bufferContent = readFileSync(tarballPath);
+    return fetch(url, {
+        method: "PUT",
+        headers: {
+            "Content-length": fileSizeInBytes.toString(),
+        },
+        body: bufferContent,
+    });
+}
+//# sourceMappingURL=file-upload.js.map

package/dist/deploy/handler.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import { logger } from "../common/logger.js";
+import { printToConsole } from "../common/output.js";
+import settings from "../common/settings.js";
+import { archive } from "./archive.js";
+import { upload } from "./file-upload.js";
+export async function deploy(argv) {
+    const archiveMetadata = await archive(argv.dir);
+    logger.info(`Tarball created locally at ${archiveMetadata}`);
+    const whoAmIResponse = await fetch(`${settings.ZUPLO_DEVELOPER_API_ENDPOINT}/v1/who-am-i`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${argv.apiKey}`,
+        },
+    });
+    if (whoAmIResponse.ok) {
+        const { account, project } = await whoAmIResponse.json();
+        const uploadUrlResponse = await fetch(`${settings.ZUPLO_DEVELOPER_API_ENDPOINT}/v1/accounts/${account}/projects/${project}/sources`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${argv.apiKey}`,
+            },
+        });
+        if (uploadUrlResponse.ok) {
+            const { uploadUrl } = await uploadUrlResponse.json();
+            const uploadResponse = await upload(archiveMetadata.tarball, uploadUrl);
+            if (uploadResponse.ok) {
+                printToConsole(chalk.green.bold(`Deploying the current branch ${archiveMetadata.metadata.branch} to project ${project} on account ${account}...`));
+            }
+            else {
+                logger.error({
+                    status: uploadResponse.status,
+                    statusText: uploadResponse.statusText,
+                }, "Failed to upload source to cloud storage");
+            }
+        }
+        else {
+            logger.error({
+                status: uploadUrlResponse.status,
+                statusText: uploadUrlResponse.statusText,
+            }, "Failed to retrieve uploadUrl");
+        }
+    }
+    else {
+        logger.error({ status: whoAmIResponse.status, statusText: whoAmIResponse.statusText }, "Failed to determine who-am-i");
+    }
+}
+//# sourceMappingURL=handler.js.map

package/dist/test/esbuild-config.js

@@ -0,0 +1,20 @@
+import { TEST_OUT_FOLDER } from "../common/constants.js";
+import { denoTestPrepPlugin } from "./esbuild-plugins/deno-test-prep-plugin.js";
+export function generateBuildOptionsForTest(argv) {
+    return {
+        outdir: `${argv.dir}/${TEST_OUT_FOLDER}`,
+        bundle: true,
+        treeShaking: true,
+        format: "esm",
+        outExtension: {
+            ".js": ".ts",
+        },
+        plugins: [
+            denoTestPrepPlugin(argv, {
+                "@zuplo/test": "",
+                chai: "https://cdn.skypack.dev/chai@4.3.4?dts",
+            }),
+        ],
+    };
+}
+//# sourceMappingURL=esbuild-config.js.map

package/dist/test/esbuild-plugins/alias.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.denoTestPrepPlugin = void 0;
+function denoTestPrepPlugin(options) {
+    const aliases = Object.keys(options);
+    const re = new RegExp(`^(${aliases.map((x) => escapeRegExp(x)).join("|")})$`);
+    return {
+        name: "alias",
+        setup(build) {
+            build.onResolve({ filter: re }, (args) => ({
+                path: options[args.path],
+                namespace: "deno-url",
+                external: true,
+            }));
+        },
+    };
+}
+exports.denoTestPrepPlugin = denoTestPrepPlugin;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=alias.js.map

package/dist/test/esbuild-plugins/deno-test-prep-plugin.js

@@ -0,0 +1,81 @@
+export function denoTestPrepPlugin(argv, options) {
+    const aliases = Object.keys(options);
+    const re = new RegExp(`^(${aliases.map((x) => escapeRegExp(x)).join("|")})$`);
+    return {
+        name: "alias",
+        setup(build) {
+            build.onResolve({ filter: re }, (args) => {
+                if (/@zuplo\/test/.test(args.path)) {
+                    return {
+                        path: args.path,
+                        namespace: "deno-url",
+                    };
+                }
+                else {
+                    return {
+                        path: options[args.path],
+                        namespace: "deno-url",
+                        external: true,
+                    };
+                }
+            });
+            build.onLoad({ filter: /.*/, namespace: "deno-url" }, (args) => {
+                if (/@zuplo\/test/.test(args.path)) {
+                    return { contents: generateTestContents(argv), loader: "ts" };
+                }
+            });
+        },
+    };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function generateTestContents(argv) {
+    return `
+
+  export const TestHelper = {
+    TEST_URL: "${argv.endpoint ?? undefined}"
+  }
+
+  import {
+    afterAll,
+    afterEach,
+    beforeAll,
+    beforeEach,
+    describe as originalDescribe,
+    it,
+  } from "https://deno.land/std@0.151.0/testing/bdd.ts"; 
+
+  // We want to be able to disable test sanitizers by default to
+  // make tests easier/more familiar to write.
+  
+  function describe<T>(
+    name: string,
+    fn: () => void | Promise<void>,
+  ): TestSuite<T> {
+    return originalDescribe(name, {
+      sanitizeExit: false,
+      sanitizeOps: false,
+      sanitizeResources: false,
+    }, fn);
+  }
+  
+  describe.only = function describeOnly<T>(
+    name: string,
+    fn: () => void | Promise<void>,
+  ): TestSuite<T> {
+    return originalDescribe.only(name, fn);
+  };
+  
+  describe.ignore = function describeIgnore<T>(
+    name: string,
+    fn: () => void | Promise<void>,
+  ): TestSuite<T> {
+    return originalDescribe.ignore(name, fn);
+  };
+
+  export {afterAll, afterEach, beforeAll, beforeEach, describe, it};
+
+  `;
+}
+//# sourceMappingURL=deno-test-prep-plugin.js.map

package/dist/test/handler.js

@@ -0,0 +1,27 @@
+import fg from "fast-glob";
+import { promisify } from "node:util";
+import rimraf from "rimraf";
+import { TEST_IN_FOLDER, TEST_OUT_FOLDER } from "../common/constants.js";
+import { logger } from "../common/logger.js";
+import { generateBuildOptionsForTest } from "./esbuild-config.js";
+import { runTests } from "./invoke-test.js";
+const rimrafp = promisify(rimraf);
+import esbuild from "esbuild";
+export async function test(argv) {
+    await rimrafp(`${argv.dir}/${TEST_OUT_FOLDER}`);
+    const result = await esbuild.build({
+        ...generateBuildOptionsForTest(argv),
+        entryPoints: fg.sync(`${argv.dir}/${TEST_IN_FOLDER}/**/*.test.ts`),
+    });
+    if (result.warnings.length > 0) {
+        logger.debug(result.warnings);
+    }
+    if (result.errors.length > 0) {
+        logger.error(result.errors, `Failed to build the test files in ${argv.dir}/${TEST_IN_FOLDER}`);
+    }
+    else {
+        const { exitCode } = await runTests(argv);
+        process.exit(exitCode);
+    }
+}
+//# sourceMappingURL=handler.js.map

package/dist/test/invoke-test.js

@@ -0,0 +1,51 @@
+import { execa } from "execa";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TEST_OUT_FOLDER } from "../common/constants.js";
+import { logger } from "../common/logger.js";
+export class MissingDenoExecutableError extends Error {
+    constructor() {
+        super("Missing executable: Cannot locate deno executable");
+        Object.setPrototypeOf(this, MissingDenoExecutableError.prototype);
+    }
+}
+async function locateDenoExecutable() {
+    return locateDeno(dirname(fileURLToPath(import.meta.url)));
+}
+async function locateDeno(dir) {
+    if (dir === ".") {
+        return undefined;
+    }
+    const pathToDeno = resolve(dir, "node_modules", "deno-bin", "bin", "deno");
+    if (await existsSync(pathToDeno)) {
+        logger.debug(`Path to deno: ${pathToDeno}`);
+        return pathToDeno;
+    }
+    return locateDeno(dirname(dir));
+}
+export async function runTests(argv) {
+    const denoExecutable = await locateDenoExecutable();
+    if (denoExecutable) {
+        const denoProcess = execa(denoExecutable, [
+            "test",
+            "--allow-net",
+            "--no-check",
+            `${argv.dir}/${TEST_OUT_FOLDER}`,
+        ]);
+        denoProcess.stdout?.pipe(process.stdout);
+        denoProcess.stderr?.pipe(process.stderr);
+        try {
+            const result = await denoProcess;
+            return result;
+        }
+        catch (err) {
+            logger.debug(err);
+            return { exitCode: err.exitCode };
+        }
+    }
+    else {
+        throw new MissingDenoExecutableError();
+    }
+}
+//# sourceMappingURL=invoke-test.js.map

package/dist/throwaway/hmm.js

@@ -0,0 +1,4 @@
+export function hmm() { }
+hmm.shit = function () { };
+hmm.weird = function () { };
+//# sourceMappingURL=hmm.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@zuplo/cli",
+  "version": "1.4.0",
+  "type": "module",
+  "repository": "https://github.com/zuplo/cli",
+  "author": "Zuplo, Inc.",
+  "license": "Copyright 2022",
+  "scripts": {
+    "build": "tsc --build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "zup": "zup.js",
+    "zup-debug": "zup-debug.js"
+  },
+  "lint-staged": {
+    "**/*.{ts,json,md,yml,js,css,html}": [
+      "prettier --write"
+    ],
+    "**/*.{ts,js}": [
+      "eslint --cache --fix --ignore-path .eslintignore"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.5",
+    "@types/rimraf": "^3.0.2",
+    "@types/tar": "^6.1.3",
+    "@types/temp": "^0.9.1",
+    "@types/yargs": "^17.0.13",
+    "@typescript-eslint/eslint-plugin": "^5.42.0",
+    "@typescript-eslint/parser": "^5.42.0",
+    "eslint": "^8.26.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-unicorn": "^44.0.2",
+    "husky": "^8.0.1",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "prettier-plugin-organize-imports": "^3.1.1",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "chalk": "^5.1.2",
+    "deno-bin": "^1.27.1",
+    "dotenv": "^16.0.3",
+    "esbuild": "^0.15.13",
+    "execa": "^6.1.0",
+    "fast-glob": "^3.2.12",
+    "ignore": "^5.2.0",
+    "pino": "^8.7.0",
+    "pino-pretty": "^9.1.1",
+    "rimraf": "^3.0.2",
+    "simple-git": "^3.14.1",
+    "tar": "^6.1.11",
+    "temp": "^0.9.4",
+    "yargs": "^17.6.0"
+  }
+}

package/zup-debug.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node --inspect-brk
+/* eslint-disable */
+process.removeAllListeners("warning");
+import "./dist/cli.js";

package/zup.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+/* eslint-disable */
+process.removeAllListeners("warning");
+import "./dist/cli.js";