@vida-global/core 1.1.0

package/lib/http/client.js

@@ -0,0 +1,129 @@
+const { logger }    = require('../logger');
+const { HttpError } = require('./error');
+
+
+class HttpClient {
+    async get(endpoint, { requestParams, headers }={}) {
+        return await this.#makeRequest(endpoint, "GET", arguments[1]);
+    }
+
+
+    async post(endpoint, { body, headers }={}) {
+        return await this.#makeRequest(endpoint, "POST", arguments[1]);
+    }
+
+
+    async put(endpoint, { body, headers }={}) {
+        return await this.#makeRequest(endpoint, "PUT", arguments[1]);
+    }
+
+
+    async delete(endpoint, { requestParams, headers }={}) {
+        return await this.#makeRequest(endpoint, "DELETE", arguments[1]);
+    }
+
+
+    async #makeRequest(endpoint, method, { requestParams, body, headers }={}) {
+        this.#logRequest(method, endpoint);
+
+        endpoint            = `${this.urlRoot}${endpoint}`;
+        const url           = new URL(endpoint);
+        const requestData   = structuredClone(requestParams || body || {});
+        const payload       = this.#prepareRequestPayload(url, requestData, headers, method);
+
+        const res  = await fetch(url.toString(), payload);
+
+        if (res.status && res.status < 300) {
+            const json = await res.json();
+            return {data: json, status: res.status};
+        } else {
+            throw new HttpError(res, payload);
+        }
+    }
+
+
+    #prepareRequestPayload(url, requestData, headers, method) {
+        const payload = {};
+
+        headers       ||= {};
+        payload.headers = {...this.defaultHeaders, ...headers};
+        payload.method  = method;
+        this.#addRequestData(payload, requestData, method, url, payload.headers);
+
+        return payload;
+    }
+
+
+    #addRequestData(payload, requestData, method, url, headers) {
+        if (method == "POST" || method == "PUT") {
+            payload.body = JSON.stringify(requestData || {});
+        } else {
+            this.#addUrlRequestData(url, requestData, headers);
+        }
+    }
+
+    #addUrlRequestData(url, requestData, headers) {
+        const contentType = headers['Content-Type'];
+        if (contentType == 'application/json') {
+            this.#addJsonUrlRequestData(requestData, url);
+        } else if (contentType == 'application/x-www-form-urlencoded') {
+            this.#addFormUrlRequestData(requestData, url);
+        }
+    }
+
+
+    #addJsonUrlRequestData(requestData, url) {
+        Object.entries(requestData).forEach(([paramName, val]) => {
+            if (typeof val == 'object') {
+                val = JSON.stringify(val);
+            }
+            url.searchParams.set(paramName, val);
+        });
+    }
+
+
+    #addFormUrlRequestData(requestData, url) {
+        Object.entries(requestData).forEach(([paramName, val]) => {
+            this.#appendUrlRequestValue(paramName, val, url)
+        });
+    }
+
+
+    #appendUrlRequestValue(paramName, val, url) {
+        if (Array.isArray(val)) {
+            val.forEach(v => url.searchParams.append(paramName, v));
+
+        } else if (typeof val == 'object') {
+            for (const [subParamName, subValue] of Object.entries(val)) {
+                this.#appendUrlRequestValue(`${paramName}[${subParamName}]`, val, formData);
+            };
+
+        } else {
+            url.searchParams.append(paramName, val);
+        }
+    }
+
+
+    #logRequest(method, endpoint) {
+        logger.info(`API CALL: ${method} ${endpoint}`);
+    }
+
+
+    get defaultHeaders() {
+        return {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        }
+    }
+
+
+    get urlRoot() {
+        return "";
+    }
+}
+
+
+module.exports = { 
+  HttpClient,
+  HttpError
+}

package/lib/http/error.js

@@ -0,0 +1,34 @@
+class HttpError extends Error {
+    #requestPayload;
+    #response;
+
+
+    constructor(response, requestPayload) {
+        super();
+        this.#response       = response;
+        this.#requestPayload = requestPayload;
+    }
+
+
+    get message()         { return `HTTP Error: ${this.status}`};
+    get status()          { return this.#response.status; }
+    get statusText()      { return this.#response.statusText; }
+    get responseHeaders() { return structuredClone(this.#response.headers); }
+    get requestPayload()  { return structuredClone(this.#requestPayload); }
+    get url()             { return this.#response.url; }
+
+
+    async data() {
+        const body = await this.#response.text();
+        try {
+            return JSON.parse(body);
+        } catch(err) {
+            return body;
+        }
+    }
+}
+
+
+module.exports = {
+  HttpError
+}

package/lib/logger/README.md

@@ -0,0 +1,2 @@
+## Logger ##
+A standard logger to be used across all Vida applications. Currently, a simple implementation of `pino`, supports the full `pino` API.

package/lib/logger/index.js

@@ -0,0 +1,16 @@
+const pino = require('pino');
+const logger = pino({
+    transport: {
+        level: process.env.LOG_LEVEL ? 'debug' : 'info',
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            ignore: 'pid,hostname',
+            translateTime: 'SYS:standard',
+            messageFormat: '{msg}',
+        }
+    },
+});
+
+
+module.exports = { logger };

package/lib/release/develop.js

@@ -0,0 +1,27 @@
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+async function develop(branchType, issueNumber, description, sourceBranch) {
+    const initials          = devInitials();
+    const parsedDescription = description.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9-]/g, '');;
+
+    const branchName = `${branchType}/${issueNumber}/${initials}/${parsedDescription}`;
+
+    const question = `Do you want to create branch ${branchName}?`;
+    const _confirm = await utils.confirmContinue(question);
+    if (!_confirm) return;
+
+    Git.createBranch(branchName, sourceBranch);
+}
+
+
+function devInitials() {
+    const name = Git.getCurrentUser()
+    return name.split(' ').map(piece => piece[0]).join('').toLowerCase();
+}
+
+
+module.exports = {
+    develop
+}

package/lib/release/git.js

@@ -0,0 +1,86 @@
+const { execSync } = require('child_process');
+
+
+function createBranch(branchName, branchToCopy=null) {
+    if (!branchToCopy) branchToCopy = getPrimaryBranch();
+
+    executeShellCommand(`git branch ${branchName} ${branchToCopy}`);
+    checkout(branchName)
+}
+
+
+function getPrimaryBranch() {
+    const allBranches = branches();
+    if (allBranches.includes('origin/master')) return 'origin/master';
+    if (allBranches.includes('origin/main'))   return 'origin/main';
+}
+
+
+function checkout(branchName) {
+    executeShellCommand(`git checkout ${branchName}`);
+}
+
+
+function pull() {
+    executeShellCommand('git pull --prune');
+}
+
+
+function push() {
+    const currBranch = getCurrentBranch();
+    executeShellCommand(`git push -u origin ${currBranch}`);
+}
+
+
+function getCurrentBranch() {
+    const allBranches = branches(false);
+    return allBranches.find(b => /^\s*\*\s+/.test(b)).replace('*', '').trim();
+}
+
+
+function forceRemotePush(sourceBranch, destBranch) {
+    executeShellCommand(`git push origin origin/${sourceBranch}:${destBranch} --force`);
+}
+
+
+function add(file) {
+    executeShellCommand(`git add ${file}`);
+}
+
+
+function commit(msg) {
+    executeShellCommand(`git commit -m '${msg}'`);
+}
+
+
+function branches(remote=true) {
+    let cmd = 'git branch';
+    if (remote) cmd = `${cmd} -r`;
+    const branches = executeShellCommand(cmd);
+    return branches.toString().split("\n").map(b => b.trim());
+}
+
+
+function getCurrentUser() {
+    return executeShellCommand(`git config user.name`).toString();
+}
+
+
+function executeShellCommand(command) {
+    return execSync(command);
+}
+
+
+module.exports = {
+    add,
+    branches,
+    checkout,
+    commit,
+    createBranch,
+    forceRemotePush,
+    getCurrentBranch,
+    getCurrentUser,
+    getPrimaryBranch,
+    pull,
+    push
+};

package/lib/release/increment.js

@@ -0,0 +1,56 @@
+const fs    = require('fs');
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+const packageJsonPath = `${process.cwd()}/package.json`;
+
+
+async function increment(type) {
+    Git.pull();
+    const currVersion = utils.getCurrentVersion();
+    const newVersion  = getNewVersion(currVersion, type);
+
+    const _confirm = await utils.confirmContinue(`Do you want to create version ${newVersion}?`);
+    if (!_confirm) return;
+
+    Git.createBranch(`release/${newVersion}`);
+    updatePackageVersion(newVersion)
+    Git.push();
+}
+
+
+function getNewVersion(currVersion, type) {
+    const newVersion = currVersion.map(v => parseInt(v));
+    switch(type) {
+        case 'major':
+            newVersion[0] += 1;
+            newVersion[1]  = 0;
+            newVersion[2]  = 0;
+            break;
+        case 'minor':
+            newVersion[1] += 1;
+            newVersion[2]  = 0;
+            break;
+        case 'point':
+            newVersion[2] += 1;
+            break;
+        default:
+            throw new Error('Invalid increment type');
+    }
+    return newVersion.join('.');
+}
+
+
+function updatePackageVersion(newVersion) {
+    let packageJson = fs.readFileSync(packageJsonPath, {encoding: 'utf8'});
+        packageJson = packageJson.replace(/"version":\s*"\d+\.\d+\.\d+"/, `"version": "${newVersion}"`);
+    fs.writeFileSync(packageJsonPath, packageJson);
+    Git.add(packageJsonPath);
+    Git.commit(`build: incrementing build to ${newVersion}`);
+}
+
+
+module.exports = {
+  increment
+}

package/lib/release/index.js

@@ -0,0 +1,10 @@
+const { increment } = require('./increment');
+const { release }   = require('./release');
+const { develop }   = require('./develop');
+
+
+module.exports = {
+    develop,
+    increment,
+    release,
+}

package/lib/release/release.js

@@ -0,0 +1,30 @@
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+async function release(env, versionToRelease=null) {
+    Git.pull();
+
+    if (versionToRelease) {
+        const branchName  = `origin/release/${versionToRelease}`;
+        const allBranches = Git.branches();
+        if (!allBranches.includes(branchName)) {
+            throw new Error(`release/${versionToRelease} does not exist`);
+        }
+    } else {
+        versionToRelease = utils.getCurrentVersion().join('.');
+    }
+
+    const question = `Do you want to release version ${versionToRelease} to ${env}?`;
+    const _confirm = await utils.confirmContinue(question);
+    if (!_confirm) return;
+    
+    const sourceBranch  = `release/${versionToRelease}`;
+    const releaseBranch = `release/${env}`;
+    Git.forceRemotePush(sourceBranch, releaseBranch);
+}
+
+
+module.exports = {
+    release
+}

package/lib/release/utils.js

@@ -0,0 +1,44 @@
+const Git = require('./git');
+
+
+function getCurrentVersion() {
+    const branches = Git.branches();
+    const releases = branches.filter(branchName => /release\/\d+\.\d+\.\d+/.test(branchName));
+    const versions = releases.map(branchName => {
+        return branchName.replace('origin/release/', '').split('.').map(n => parseInt(n));
+    });
+    
+    versions.sort((v1,v2) => {
+        if (v1[0] != v2[0]) return v2[0] - v1[0];
+        if (v1[1] != v2[1]) return v2[1] - v1[1];
+        return v2[2] - v1[2];
+    });
+
+    return versions[0] || [1,0,0];
+}
+
+
+async function confirmContinue(question) {
+    return await getInput(question, ['y','n']) == 'y';
+}
+
+
+async function getInput(question, options) {
+    const readline = require('node:readline/promises').createInterface({
+        input:  process.stdin,
+        output: process.stdout
+    });
+
+    const response = await readline.question(`${question} [${options.join(',')}] `);
+    readline.close();
+
+    if (options.includes(response)) return response;
+    return getInput(question, options);
+}
+
+
+module.exports = {
+    confirmContinue,
+    getCurrentVersion,
+    getInput,
+}

package/lib/server/README.md

@@ -0,0 +1,37 @@
+# VidaServer
+The `VidaServer` is a general purpose wrapper around an `express` server. It initializes standard middleware that we want running on all Vida application servers and leaves hooks for adding additional middleware on subclasses for specific use cases.
+The `VidaServer` works in conjunction with the `VidaServerController`. When a `VidaServer` begins listening, it searches its directory structure (as defined in the `controllerDirectories` getter) for subclasses of `VidaServerController`. It then creates routes based on all methods of the controller that are prefixed with `get`, `post`, `put`, `patch`, or `delete`. 
+The paths for these routes are defined by the directory structure of the controller, the name of the controller, and the name of the method. For example, a method `getFoo` defined on a `BarController` in the directory `/controllers/baz`, will create the route `GET /baz/bar/foo`. “Index” will yield an empty path (e.g. `getIndex` in the previously described controller generates `GET /baz/bar`). However, the default paths can be overridden by defining the `routes` getter.
+Each controller method will have direct access to request and response variables and a logger. Calling `render` will set the response body. It accepts either a string or a JSON object.
+```
+class UsersController extends ServerController {
+    // GET /users
+    getIndex() {
+        const users = getUsers(this.query.pageNumber, this.query.pageSize);
+        this.render(users.toJson());
+    }
+
+    // PUT /users/foo
+    putFoo() {
+        this.logger.info("Putting Foo");
+        this.render("hello world");
+    }
+
+    // POST /user/:id
+    postUpdateUser() {
+        const user = getUser(this.params.id);
+        if (!user) {
+            this.status = 404;
+            this.render({error: "No user found"});
+            return;
+        }
+        user.update(this.body.user);
+        this.render({success: true});
+    }
+
+    static get routes() {
+        return {postUpdateUser: '/user/:id'};
+    }
+}
+```
+

package/lib/server/index.js

@@ -0,0 +1,9 @@
+const { VidaServer }           = require('./server');
+const { AuthorizationError,
+        VidaServerController } = require('./serverController');
+
+module.exports = {
+    AuthorizationError,
+    VidaServer,
+    VidaServerController,
+}