@cloud-cli/env 1.0.0

package/.github/workflows/cicd.yml

@@ -0,0 +1,13 @@
+name: CICD
+on:
+  push:
+    branches:
+      - main
+jobs:
+  release:
+    uses: homebots/workflows/.github/workflows/node-build-release.yml@master
+    with:
+      branches: main
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/README.md

@@ -0,0 +1,3 @@
+# env
+
+Storage for app environment variables

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export interface App {
+    app: string;
+}
+export interface KeyValue {
+    key: string;
+    value?: string;
+}
+export interface AppKeyValue extends App, KeyValue {
+}
+declare function reload(): void;
+declare function show(options: App): Promise<unknown>;
+declare function set(options: AppKeyValue): Promise<unknown>;
+declare function remove(options: AppKeyValue): Promise<unknown>;
+declare function get(options: Omit<AppKeyValue, 'value'>): Promise<unknown>;
+declare const _default: {
+    reload: typeof reload;
+    show: typeof show;
+    get: typeof get;
+    set: typeof set;
+    delete: typeof remove;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,104 @@
+import sqlite from 'sqlite3';
+import { join } from 'path';
+const appNotSpecifiedError = new Error('App not specified');
+const keyNotSpecifiedError = new Error('Key not specified');
+let db;
+const columns = {
+    App: 'app',
+    Key: 'key',
+    Value: 'value',
+};
+function close() {
+    try {
+        if (db) {
+            db.close();
+        }
+    }
+    catch { }
+    ;
+}
+function reload() {
+    close();
+    const inMemory = !!process.env.IN_MEMORY_DB;
+    if (inMemory) {
+        sqlite.verbose();
+    }
+    const databasePath = inMemory ? ':memory:' : join(process.cwd(), 'env.db');
+    db = new sqlite.Database(databasePath);
+    db.run(`CREATE TABLE IF NOT EXISTS env (
+      ${columns.App} TEXT,
+      ${columns.Key} TEXT,
+      ${columns.Value} TEXT,
+      UNIQUE (${columns.App}, ${columns.Key})
+  )`);
+}
+async function show(options) {
+    return new Promise((resolve, reject) => {
+        const { app } = options;
+        if (!app) {
+            return reject(appNotSpecifiedError);
+        }
+        db
+            .prepare(`
+        SELECT
+          ${columns.App},
+          ${columns.Key},
+          ${columns.Value}
+        FROM env WHERE
+        ${columns.App} = ?`)
+            .all([app], (error, rows) => error ? reject(error) : resolve(rows));
+    });
+}
+async function set(options) {
+    const { app, key, value } = options;
+    if (!app) {
+        return Promise.reject(appNotSpecifiedError);
+    }
+    if (!key) {
+        return Promise.reject(keyNotSpecifiedError);
+    }
+    return query('REPLACE INTO env VALUES (?, ?, ?)', [app, key, value]);
+}
+async function remove(options) {
+    const { app, key } = options;
+    if (!app) {
+        return Promise.reject(appNotSpecifiedError);
+    }
+    if (!key) {
+        return Promise.reject(keyNotSpecifiedError);
+    }
+    return query(`DELETE FROM env WHERE ${columns.App} = ? AND ${columns.Key} = ?`, [app, key]);
+}
+async function get(options) {
+    return new Promise((resolve, reject) => {
+        const { app, key } = options;
+        if (!app) {
+            return reject(appNotSpecifiedError);
+        }
+        if (!key) {
+            return reject(keyNotSpecifiedError);
+        }
+        db.serialize(() => {
+            db
+                .prepare(`
+          SELECT
+            ${columns.App},
+            ${columns.Key},
+            ${columns.Value}
+          FROM env WHERE
+            ${columns.App} = ? AND ${columns.Key} = ?`)
+                .all([app, key], (error, rows) => (error ? reject(error) : resolve(rows[0])));
+        });
+    });
+}
+async function query(statement, inputs) {
+    return new Promise((resolve, reject) => {
+        db.serialize(() => {
+            db
+                .prepare(statement)
+                .run(inputs)
+                .finalize((error) => (error ? reject(error) : resolve(null)));
+        });
+    });
+}
+export default { reload, show, get, set, delete: remove };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@cloud-cli/env",
+  "version": "1.0.0",
+  "description": "Storage for app environment variables",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "tdd": "jest --watchAll",
+    "build": "rm -rf ./dist/* && tsc --project ./tsconfig.json"
+  },
+  "keywords": [
+    "cloudy"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/core": "^7.21.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-typescript": "^7.21.0",
+    "@types/jest": "^27.0.1",
+    "@types/node": "^14.18.21",
+    "babel-jest": "^29.4.3",
+    "jest": "^29.4.3",
+    "nodemon": "^2.0.16",
+    "ts-jest": "^29.0.5",
+    "ts-jest-resolver": "^2.0.0",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.8.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cloud-cli/env.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "sqlite3": "^5.1.4"
+  }
+}

package/src/index.spec.js

@@ -0,0 +1,28 @@
+import env from './index';
+
+beforeAll(() => {
+  process.env.IN_MEMORY_DB = true;
+});
+
+const app = { app: 'test' };
+const envVariable = { app: 'test', key: 'key', value: 'ok' };
+
+describe('env', () => {
+  it('should store variables for an app', async () => {
+    env.reload();
+    await expect(env.set({ app: '', key: '' })).rejects.toEqual(new Error('App not specified'));
+    await expect(env.set({ app: 'test', key: '' })).rejects.toEqual(new Error('Key not specified'));
+    await expect(env.get({ app: 'test', key: 'key' })).resolves.toEqual(undefined);
+
+    // upsert
+    await expect(env.set(envVariable)).resolves.toBeNull();
+    await expect(env.set(envVariable)).resolves.toBeNull();
+
+    await expect(env.get({ app: 'test', key: 'key' })).resolves.toEqual(envVariable);
+
+    await expect(env.show(app)).resolves.toEqual([envVariable]);
+
+    await expect(env.delete(envVariable)).resolves.toBeNull();
+    await expect(env.show(app)).resolves.toEqual([]);
+  });
+});

package/src/index.ts

@@ -0,0 +1,140 @@
+import sqlite from 'sqlite3';
+import { join } from 'path';
+
+const appNotSpecifiedError = new Error('App not specified');
+const keyNotSpecifiedError = new Error('Key not specified');
+let db: sqlite.Database;
+
+const columns = {
+  App: 'app',
+  Key: 'key',
+  Value: 'value',
+};
+
+export interface App {
+  app: string;
+}
+
+export interface KeyValue {
+  key: string;
+  value?: string;
+}
+
+export interface AppKeyValue extends App, KeyValue { }
+
+function close() {
+  try {
+    if (db) {
+      db.close();
+    }
+  } catch { };
+}
+
+function reload() {
+  close();
+
+  const inMemory = !!process.env.IN_MEMORY_DB;
+
+  if (inMemory) {
+    sqlite.verbose();
+  }
+
+  const databasePath = inMemory ? ':memory:' : join(process.cwd(), 'env.db');
+
+  db = new sqlite.Database(databasePath);
+  db.run(`CREATE TABLE IF NOT EXISTS env (
+      ${columns.App} TEXT,
+      ${columns.Key} TEXT,
+      ${columns.Value} TEXT,
+      UNIQUE (${columns.App}, ${columns.Key})
+  )`);
+}
+
+async function show(options: App) {
+  return new Promise((resolve, reject) => {
+    const { app } = options;
+
+    if (!app) {
+      return reject(appNotSpecifiedError);
+    }
+
+    db
+      .prepare(`
+        SELECT
+          ${columns.App},
+          ${columns.Key},
+          ${columns.Value}
+        FROM env WHERE
+        ${columns.App} = ?`
+      )
+      .all([app], (error, rows) => error ? reject(error) : resolve(rows));
+  });
+}
+
+async function set(options: AppKeyValue) {
+  const { app, key, value } = options;
+
+  if (!app) {
+    return Promise.reject(appNotSpecifiedError);
+  }
+
+  if (!key) {
+    return Promise.reject(keyNotSpecifiedError);
+  }
+
+  return query('REPLACE INTO env VALUES (?, ?, ?)', [app, key, value]);
+}
+
+async function remove(options: AppKeyValue) {
+  const { app, key } = options;
+
+  if (!app) {
+    return Promise.reject(appNotSpecifiedError);
+  }
+
+  if (!key) {
+    return Promise.reject(keyNotSpecifiedError);
+  }
+
+  return query(`DELETE FROM env WHERE ${columns.App} = ? AND ${columns.Key} = ?`, [app, key])
+}
+
+async function get(options: Omit<AppKeyValue, 'value'>) {
+  return new Promise((resolve, reject) => {
+    const { app, key } = options;
+
+    if (!app) {
+      return reject(appNotSpecifiedError);
+    }
+
+    if (!key) {
+      return reject(keyNotSpecifiedError);
+    }
+
+    db.serialize(() => {
+      db
+        .prepare(`
+          SELECT
+            ${columns.App},
+            ${columns.Key},
+            ${columns.Value}
+          FROM env WHERE
+            ${columns.App} = ? AND ${columns.Key} = ?`
+        )
+        .all([app, key], (error, rows) => (error ? reject(error) : resolve(rows[0])));
+    });
+  });
+}
+
+async function query(statement, inputs) {
+  return new Promise((resolve, reject) => {
+    db.serialize(() => {
+      db
+        .prepare(statement)
+        .run(inputs)
+        .finalize((error) => (error ? reject(error) : resolve(null)));
+    });
+  })
+}
+
+export default { reload, show, get, set, delete: remove };

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "module": "esnext",
+    "target": "es2020",
+    "lib": ["ESNext"],
+    "esModuleInterop": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "./dist",
+    "declaration": true
+  },
+  "include": ["./src/**/*.ts"]
+}