@appconda/sdk 1.0.194 → 1.0.409

package/dist/lib/Cache/Adapters/Memory.js

@@ -0,0 +1,47 @@
+export class Memory {
+    constructor() {
+        this.store = {};
+    }
+    async load(key, ttl, hash = '') {
+        if (key && this.store[key]) {
+            const saved = this.store[key];
+            return (saved.time + ttl > Date.now() / 1000) ? saved.data : false;
+        }
+        return false;
+    }
+    async save(key, data, hash = '') {
+        if (!key || !data) {
+            return false;
+        }
+        const saved = {
+            time: Date.now() / 1000,
+            data: data,
+        };
+        this.store[key] = saved;
+        return data;
+    }
+    async list(key) {
+        return [];
+    }
+    async purge(key, hash = '') {
+        if (key && this.store[key]) {
+            delete this.store[key];
+            return true;
+        }
+        return false;
+    }
+    async flush() {
+        this.store = {};
+        return true;
+    }
+    async ping() {
+        return true;
+    }
+    async getSize() {
+        return Object.keys(this.store).length;
+    }
+    async delWithStart(pattern) {
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Cache/Adapters/None.d.ts

@@ -0,0 +1,12 @@
+import { Adapter } from "../Adapter";
+export declare class None implements Adapter {
+    constructor();
+    load(key: string, ttl: number, hash?: string): Promise<any>;
+    save(key: string, data: any, hash?: string): Promise<boolean | string | any[]>;
+    list(key: string): Promise<string[]>;
+    purge(key: string, hash?: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    ping(): Promise<boolean>;
+    getSize(): Promise<number>;
+    delWithStart(pattern: string): Promise<number>;
+}

package/dist/lib/Cache/Adapters/None.js

@@ -0,0 +1,28 @@
+export class None {
+    constructor() { }
+    async load(key, ttl, hash = '') {
+        return false;
+    }
+    async save(key, data, hash = '') {
+        return false;
+    }
+    async list(key) {
+        return [];
+    }
+    async purge(key, hash = '') {
+        return true;
+    }
+    async flush() {
+        return true;
+    }
+    async ping() {
+        return true;
+    }
+    async getSize() {
+        return 0;
+    }
+    async delWithStart(pattern) {
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Cache/Adapters/Sharding.d.ts

@@ -0,0 +1,17 @@
+import { Adapter } from "../Adapter";
+export declare class Sharding implements Adapter {
+    protected adapters: Adapter[];
+    protected count: number;
+    constructor(adapters: Adapter[]);
+    load(key: string, ttl: number, hash?: string): Promise<any>;
+    save(key: string, data: any, hash?: string): Promise<boolean | string | any[]>;
+    list(key: string): Promise<string[]>;
+    purge(key: string, hash?: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    ping(): Promise<boolean>;
+    getSize(): Promise<number>;
+    protected getAdapter(key: string): Adapter;
+    private crc32;
+    delWithStart(pattern: string): Promise<number>;
+    private crc32Table;
+}

package/dist/lib/Cache/Adapters/Sharding.js

@@ -0,0 +1,73 @@
+export class Sharding {
+    constructor(adapters) {
+        this.count = 0;
+        this.crc32Table = (() => {
+            let c;
+            const table = [];
+            for (let n = 0; n < 256; n++) {
+                c = n;
+                for (let k = 0; k < 8; k++) {
+                    c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+                }
+                table[n] = c;
+            }
+            return table;
+        })();
+        if (adapters.length === 0) {
+            throw new Error('No adapters provided');
+        }
+        this.count = adapters.length;
+        this.adapters = adapters;
+    }
+    async load(key, ttl, hash = '') {
+        const adapter = this.getAdapter(key);
+        return await adapter.load(key, ttl, hash);
+    }
+    async save(key, data, hash = '') {
+        return this.getAdapter(key).save(key, data, hash);
+    }
+    async list(key) {
+        return this.getAdapter(key).list(key);
+    }
+    async purge(key, hash = '') {
+        return this.getAdapter(key).purge(key, hash);
+    }
+    async flush() {
+        let result = true;
+        for (const adapter of this.adapters) {
+            result = await adapter.flush() ? result : false;
+        }
+        return result;
+    }
+    async ping() {
+        for (const adapter of this.adapters) {
+            if (!adapter.ping()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async getSize() {
+        let size = 0;
+        for (const adapter of this.adapters) {
+            size += await adapter.getSize();
+        }
+        return size;
+    }
+    getAdapter(key) {
+        const hash = this.crc32(key);
+        const index = hash % this.count;
+        return this.adapters[index];
+    }
+    crc32(str) {
+        let crc = 0 ^ (-1);
+        for (let i = 0; i < str.length; i++) {
+            crc = (crc >>> 8) ^ this.crc32Table[(crc ^ str.charCodeAt(i)) & 0xff];
+        }
+        return (crc ^ (-1)) >>> 0;
+    }
+    async delWithStart(pattern) {
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Cache/Cache.d.ts

@@ -0,0 +1,16 @@
+import { Adapter } from "./Adapter";
+export declare class Cache {
+    private adapter;
+    static caseSensitive: boolean;
+    constructor(adapter: Adapter);
+    private constructKey;
+    static setCaseSensitivity(value: boolean): boolean;
+    load(key: string | string[], ttl?: number, hash?: string): Promise<any>;
+    save(key: string | string[], data: any, hash?: string): Promise<boolean | string | any[]>;
+    list(key: string | string[]): Promise<string[]>;
+    purge(key: string | string[], hash?: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    ping(): Promise<boolean>;
+    getSize(): Promise<number>;
+    delWithStart(keys: string | string[]): Promise<number>;
+}

package/dist/lib/Cache/Cache.js

@@ -0,0 +1,52 @@
+export class Cache {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    constructKey(key) {
+        if (Array.isArray(key)) {
+            key = key.join(':');
+        }
+        return key;
+    }
+    static setCaseSensitivity(value) {
+        return this.caseSensitive = value;
+    }
+    async load(key, ttl = 60 * 60 * 24, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return await this.adapter.load(key, ttl, hash);
+    }
+    async save(key, data, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return this.adapter.save(key, data, hash);
+    }
+    async list(key) {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        return this.adapter.list(key);
+    }
+    async purge(key, hash = '') {
+        key = this.constructKey(key);
+        key = Cache.caseSensitive ? key : key.toLowerCase();
+        hash = Cache.caseSensitive ? hash : hash.toLowerCase();
+        return this.adapter.purge(key, hash);
+    }
+    async flush() {
+        return this.adapter.flush();
+    }
+    async ping() {
+        return this.adapter.ping();
+    }
+    async getSize() {
+        return this.adapter.getSize();
+    }
+    async delWithStart(keys) {
+        const pattern = this.constructKey(keys);
+        return this.adapter.delWithStart(pattern);
+    }
+}
+Cache.caseSensitive = false;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Cache/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Cache';
+export * from './Adapters/None';
+export * from './Adapters/Sharding';
+export * from './Adapters/Memory';

package/dist/lib/Cache/index.js

@@ -0,0 +1,5 @@
+export * from './Cache';
+export * from './Adapters/None';
+export * from './Adapters/Sharding';
+export * from './Adapters/Memory';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL0NhY2hlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9DYWNoZSc7XG5leHBvcnQgKiBmcm9tICcuL0FkYXB0ZXJzL05vbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9BZGFwdGVycy9TaGFyZGluZyc7XG5leHBvcnQgKiBmcm9tICcuL0FkYXB0ZXJzL01lbW9yeSc7Il19

package/dist/lib/Cache/test.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvQ2FjaGUvdGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiIl19

package/dist/lib/Registry/Registry.d.ts

@@ -0,0 +1,38 @@
+export declare class Registry {
+    /**
+     * List of all callbacks
+     */
+    protected callbacks: {
+        [key: string]: () => any;
+    };
+    /**
+     * List of all fresh resources
+     */
+    protected fresh: {
+        [key: string]: boolean;
+    };
+    /**
+     * List of all connections
+     */
+    protected registry: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+    /**
+     * Current context
+     */
+    protected _context: string;
+    /**
+     * Set a new connection callback
+     */
+    set(name: string, callback: () => any, fresh?: boolean): this;
+    /**
+     * If connection has been created returns it, otherwise create and then return it
+     */
+    get(name: string, fresh?: boolean): any;
+    /**
+     * Set the current context
+     */
+    context(name: string): this;
+}

package/dist/lib/Registry/Registry.js

@@ -0,0 +1,56 @@
+export class Registry {
+    constructor() {
+        /**
+         * List of all callbacks
+         */
+        this.callbacks = {};
+        /**
+         * List of all fresh resources
+         */
+        this.fresh = {};
+        /**
+         * List of all connections
+         */
+        this.registry = {
+            'default': {},
+        };
+        /**
+         * Current context
+         */
+        this._context = 'default';
+    }
+    /**
+     * Set a new connection callback
+     */
+    set(name, callback, fresh = false) {
+        if (this.registry[this._context].hasOwnProperty(name)) {
+            delete this.registry[this._context][name];
+        }
+        this.fresh[name] = fresh;
+        this.callbacks[name] = callback;
+        return this;
+    }
+    /**
+     * If connection has been created returns it, otherwise create and then return it
+     */
+    get(name, fresh = false) {
+        if (!this.registry[this._context].hasOwnProperty(name) || fresh || this.fresh[name]) {
+            if (!this.callbacks.hasOwnProperty(name)) {
+                throw new Error(`No callback named "${name}" found when trying to create connection`);
+            }
+            this.registry[this._context][name] = this.callbacks[name]();
+        }
+        return this.registry[this._context][name];
+    }
+    /**
+     * Set the current context
+     */
+    context(name) {
+        if (!this.registry.hasOwnProperty(name)) {
+            this.registry[name] = {};
+        }
+        this._context = name;
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Registry/index.d.ts

@@ -0,0 +1 @@
+export * from './Registry';

package/dist/lib/Registry/index.js

@@ -0,0 +1,2 @@
+export * from './Registry';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL1JlZ2lzdHJ5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9SZWdpc3RyeSc7Il19

package/dist/lib/Services.d.ts

@@ -0,0 +1,6 @@
+import { Cache } from "./Cache";
+import { Registry } from "./Registry";
+export declare const registry: Registry;
+export declare class Services {
+    static get Cache(): Cache;
+}

package/dist/lib/Services.js

@@ -0,0 +1,14 @@
+import { Cache, Memory } from "./Cache";
+import { Registry } from "./Registry";
+export const registry = new Registry();
+registry.set('cache', () => {
+    const memoryAdapter = new Memory();
+    const cacheProvider = new Cache(memoryAdapter);
+    return cacheProvider;
+});
+export class Services {
+    static get Cache() {
+        return registry.get('cache');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VydmljZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL1NlcnZpY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFLdEMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLElBQUksUUFBUSxFQUFFLENBQUM7QUFFdkMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFO0lBR3ZCLE1BQU0sYUFBYSxHQUFHLElBQUksTUFBTSxFQUFFLENBQUM7SUFFbkMsTUFBTSxhQUFhLEdBQUcsSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUM7SUFFL0MsT0FBTyxhQUFhLENBQUM7QUFFekIsQ0FBQyxDQUFDLENBQUE7QUFFRixNQUFNLE9BQU8sUUFBUTtJQUNWLE1BQU0sS0FBSyxLQUFLO1FBQ25CLE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBRUoiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYWNoZSwgTWVtb3J5IH0gZnJvbSBcIi4vQ2FjaGVcIjtcbmltcG9ydCB7IFJlZ2lzdHJ5IH0gZnJvbSBcIi4vUmVnaXN0cnlcIjtcblxuXG5cblxuZXhwb3J0IGNvbnN0IHJlZ2lzdHJ5ID0gbmV3IFJlZ2lzdHJ5KCk7XG5cbnJlZ2lzdHJ5LnNldCgnY2FjaGUnLCAoKSA9PiB7XG4gIFxuXG4gICAgY29uc3QgbWVtb3J5QWRhcHRlciA9IG5ldyBNZW1vcnkoKTtcblxuICAgIGNvbnN0IGNhY2hlUHJvdmlkZXIgPSBuZXcgQ2FjaGUobWVtb3J5QWRhcHRlcik7XG5cbiAgICByZXR1cm4gY2FjaGVQcm92aWRlcjtcblxufSlcblxuZXhwb3J0IGNsYXNzIFNlcnZpY2VzIHtcbiAgICBwdWJsaWMgc3RhdGljIGdldCBDYWNoZSgpOiBDYWNoZSB7XG4gICAgICAgIHJldHVybiByZWdpc3RyeS5nZXQoJ2NhY2hlJyk7XG4gICAgfVxuICAgXG59Il19

package/dist/lib/crypto.d.ts

@@ -0,0 +1,23 @@
+/**
+ *
+ * @param text Value to be encrypted
+ * @param key Key used to encrypt value must be 32 bytes for AES256 encryption algorithm
+ *
+ * @returns Encrypted value using key
+ */
+export declare const symmetricEncrypt: (text: string, key: string) => string;
+/**
+ *
+ * @param text Value to decrypt
+ * @param key Key used to decrypt value must be 32 bytes for AES256 encryption algorithm
+ */
+export declare const symmetricDecrypt: (text: string, key: string) => string;
+export declare const getHash: (key: string) => string;
+export declare const encryptAES128: (encryptionKey: string, data: string) => string;
+export declare const decryptAES128: (encryptionKey: string, data: string) => string;
+export declare const generateLocalSignedUrl: (fileName: string, environmentId: string, fileType: string) => {
+    signature: string;
+    uuid: string;
+    timestamp: number;
+};
+export declare const validateLocalSignedUrl: (uuid: string, fileName: string, environmentId: string, fileType: string, timestamp: number, signature: string, secret: string) => boolean;

package/dist/lib/crypto.js

@@ -0,0 +1,78 @@
+import crypto from "crypto";
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes } from "crypto";
+import { getEnv } from "./env";
+const ALGORITHM = "aes256";
+const INPUT_ENCODING = "utf8";
+const OUTPUT_ENCODING = "hex";
+const IV_LENGTH = 16; // AES blocksize
+/**
+ *
+ * @param text Value to be encrypted
+ * @param key Key used to encrypt value must be 32 bytes for AES256 encryption algorithm
+ *
+ * @returns Encrypted value using key
+ */
+export const symmetricEncrypt = (text, key) => {
+    const BUFFER_ENCODING = getEnv().ENCRYPTION_KEY.length === 32 ? "latin1" : "hex";
+    const _key = Buffer.from(key, BUFFER_ENCODING);
+    const iv = crypto.randomBytes(IV_LENGTH);
+    // @ts-ignore -- the package needs to be built
+    const cipher = crypto.createCipheriv(ALGORITHM, _key, iv);
+    let ciphered = cipher.update(text, INPUT_ENCODING, OUTPUT_ENCODING);
+    ciphered += cipher.final(OUTPUT_ENCODING);
+    const ciphertext = iv.toString(OUTPUT_ENCODING) + ":" + ciphered;
+    return ciphertext;
+};
+/**
+ *
+ * @param text Value to decrypt
+ * @param key Key used to decrypt value must be 32 bytes for AES256 encryption algorithm
+ */
+export const symmetricDecrypt = (text, key) => {
+    const BUFFER_ENCODING = getEnv().ENCRYPTION_KEY.length === 32 ? "latin1" : "hex";
+    const _key = Buffer.from(key, BUFFER_ENCODING);
+    const components = text.split(":");
+    const iv_from_ciphertext = Buffer.from(components.shift() || "", OUTPUT_ENCODING);
+    // @ts-ignore -- the package needs to be built
+    const decipher = crypto.createDecipheriv(ALGORITHM, _key, iv_from_ciphertext);
+    let deciphered = decipher.update(components.join(":"), OUTPUT_ENCODING, INPUT_ENCODING);
+    deciphered += decipher.final(INPUT_ENCODING);
+    return deciphered;
+};
+export const getHash = (key) => createHash("sha256").update(key).digest("hex");
+// create an aes128 encryption function
+export const encryptAES128 = (encryptionKey, data) => {
+    // @ts-ignore -- the package needs to be built
+    const cipher = createCipheriv("aes-128-ecb", Buffer.from(encryptionKey, "base64"), "");
+    let encrypted = cipher.update(data, "utf-8", "hex");
+    encrypted += cipher.final("hex");
+    return encrypted;
+};
+// create an aes128 decryption function
+export const decryptAES128 = (encryptionKey, data) => {
+    // @ts-ignore -- the package needs to be built
+    const cipher = createDecipheriv("aes-128-ecb", Buffer.from(encryptionKey, "base64"), "");
+    let decrypted = cipher.update(data, "hex", "utf-8");
+    decrypted += cipher.final("utf-8");
+    return decrypted;
+};
+export const generateLocalSignedUrl = (fileName, environmentId, fileType) => {
+    const uuid = randomBytes(16).toString("hex");
+    const timestamp = Date.now();
+    const data = `${uuid}:${fileName}:${environmentId}:${fileType}:${timestamp}`;
+    const signature = createHmac("sha256", getEnv().ENCRYPTION_KEY).update(data).digest("hex");
+    return { signature, uuid, timestamp };
+};
+export const validateLocalSignedUrl = (uuid, fileName, environmentId, fileType, timestamp, signature, secret) => {
+    const data = `${uuid}:${fileName}:${environmentId}:${fileType}:${timestamp}`;
+    const expectedSignature = createHmac("sha256", secret).update(data).digest("hex");
+    if (expectedSignature !== signature) {
+        return false;
+    }
+    // valid for 5 minutes
+    if (Date.now() - timestamp > 1000 * 60 * 5) {
+        return false;
+    }
+    return true;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/lib/crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes } from \"crypto\";\nimport { getEnv } from \"./env\";\n\n\nconst ALGORITHM = \"aes256\";\nconst INPUT_ENCODING = \"utf8\";\nconst OUTPUT_ENCODING = \"hex\";\n\nconst IV_LENGTH = 16; // AES blocksize\n\n/**\n *\n * @param text Value to be encrypted\n * @param key Key used to encrypt value must be 32 bytes for AES256 encryption algorithm\n *\n * @returns Encrypted value using key\n */\nexport const symmetricEncrypt = (text: string, key: string) => {\n  const BUFFER_ENCODING = getEnv().ENCRYPTION_KEY!.length === 32 ? \"latin1\" : \"hex\";\n  const _key = Buffer.from(key, BUFFER_ENCODING);\n  const iv = crypto.randomBytes(IV_LENGTH);\n\n  // @ts-ignore -- the package needs to be built\n  const cipher = crypto.createCipheriv(ALGORITHM, _key, iv);\n  let ciphered = cipher.update(text, INPUT_ENCODING, OUTPUT_ENCODING);\n  ciphered += cipher.final(OUTPUT_ENCODING);\n  const ciphertext = iv.toString(OUTPUT_ENCODING) + \":\" + ciphered;\n\n  return ciphertext;\n};\n\n/**\n *\n * @param text Value to decrypt\n * @param key Key used to decrypt value must be 32 bytes for AES256 encryption algorithm\n */\nexport const symmetricDecrypt = (text: string, key: string) => {\n  const BUFFER_ENCODING = getEnv().ENCRYPTION_KEY!.length === 32 ? \"latin1\" : \"hex\";\n  const _key = Buffer.from(key, BUFFER_ENCODING);\n\n  const components = text.split(\":\");\n  const iv_from_ciphertext = Buffer.from(components.shift() || \"\", OUTPUT_ENCODING);\n  // @ts-ignore -- the package needs to be built\n  const decipher = crypto.createDecipheriv(ALGORITHM, _key, iv_from_ciphertext);\n  let deciphered = decipher.update(components.join(\":\"), OUTPUT_ENCODING, INPUT_ENCODING);\n  deciphered += decipher.final(INPUT_ENCODING);\n\n  return deciphered;\n};\n\nexport const getHash = (key: string): string => createHash(\"sha256\").update(key).digest(\"hex\");\n\n// create an aes128 encryption function\nexport const encryptAES128 = (encryptionKey: string, data: string): string => {\n  // @ts-ignore -- the package needs to be built\n  const cipher = createCipheriv(\"aes-128-ecb\", Buffer.from(encryptionKey, \"base64\"), \"\");\n  let encrypted = cipher.update(data, \"utf-8\", \"hex\");\n  encrypted += cipher.final(\"hex\");\n  return encrypted;\n};\n// create an aes128 decryption function\nexport const decryptAES128 = (encryptionKey: string, data: string): string => {\n  // @ts-ignore -- the package needs to be built\n  const cipher = createDecipheriv(\"aes-128-ecb\", Buffer.from(encryptionKey, \"base64\"), \"\");\n  let decrypted = cipher.update(data, \"hex\", \"utf-8\");\n  decrypted += cipher.final(\"utf-8\");\n  return decrypted;\n};\n\nexport const generateLocalSignedUrl = (\n  fileName: string,\n  environmentId: string,\n  fileType: string\n): { signature: string; uuid: string; timestamp: number } => {\n  const uuid = randomBytes(16).toString(\"hex\");\n  const timestamp = Date.now();\n  const data = `${uuid}:${fileName}:${environmentId}:${fileType}:${timestamp}`;\n  const signature = createHmac(\"sha256\", getEnv().ENCRYPTION_KEY!).update(data).digest(\"hex\");\n  return { signature, uuid, timestamp };\n};\n\nexport const validateLocalSignedUrl = (\n  uuid: string,\n  fileName: string,\n  environmentId: string,\n  fileType: string,\n  timestamp: number,\n  signature: string,\n  secret: string\n): boolean => {\n  const data = `${uuid}:${fileName}:${environmentId}:${fileType}:${timestamp}`;\n  const expectedSignature = createHmac(\"sha256\", secret).update(data).digest(\"hex\");\n\n  if (expectedSignature !== signature) {\n    return false;\n  }\n\n  // valid for 5 minutes\n  if (Date.now() - timestamp > 1000 * 60 * 5) {\n    return false;\n  }\n\n  return true;\n};\n"]}

package/dist/lib/env.d.ts

@@ -0,0 +1 @@
+export declare const getEnv: () => any;