@aptana/multichannel-common 2.9.12

package/core/infrastructure/cache/Repo.d.ts

@@ -0,0 +1,25 @@
+import { Repo as Cache } from '../../../core/domain/cache/Repo';
+import { Store } from '../../../core/domain/cache/Store';
+export declare class Repo implements Cache {
+    protected store: Store;
+    protected ttl: number;
+    constructor(store: Store);
+    has(key: string): Promise<boolean>;
+    missing(key: string): Promise<boolean>;
+    get<T>(key: string, _default?: any): Promise<T | null>;
+    pull<T>(key: string, _default?: any): Promise<T | null>;
+    put(key: string, value: any, ttl?: number): Promise<boolean>;
+    add(key: string, value: any, ttl?: number): Promise<boolean>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    remember<T>(key: string, callback: Function, ttl?: number): Promise<T>;
+    rememberForever<T>(key: string, callback: Function): Promise<T>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    getDefaultCacheTime(): number;
+    setDefaultCacheTime(ttl: number): Repo;
+    getStore(): Store;
+    setStore(store: Store): Repo;
+    protected itemKey(key: string): string;
+    protected getSeconds(ttl: any): number;
+    private value;
+}

package/core/infrastructure/cache/Repo.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repo = void 0;
+class Repo {
+    store;
+    ttl;
+    constructor(store) {
+        this.store = store;
+        this.ttl = 3600;
+    }
+    async has(key) {
+        return !!await this.get(key);
+    }
+    async missing(key) {
+        return !await this.has(key);
+    }
+    async get(key, _default) {
+        const value = await this.store.get(this.itemKey(key));
+        return value || await this.value(_default);
+    }
+    async pull(key, _default) {
+        const value = await this.get(key);
+        if (value) {
+            await this.forget(key);
+        }
+        return value || await this.value(_default);
+    }
+    async put(key, value, ttl = this.ttl) {
+        const seconds = this.getSeconds(ttl);
+        if (seconds <= 0) {
+            return await this.forget(key);
+        }
+        const result = await this.store.put(this.itemKey(key), value, seconds);
+        return result;
+    }
+    async add(key, value, ttl = this.ttl) {
+        let seconds = undefined;
+        if (!ttl) {
+            seconds = this.getSeconds(ttl);
+            if (seconds <= 0) {
+                return false;
+            }
+        }
+        if (await this.missing(key)) {
+            return await this.put(key, value, seconds);
+        }
+        return false;
+    }
+    async forever(key, value) {
+        const result = await this.store.forever(this.itemKey(key), value);
+        return result;
+    }
+    async remember(key, callback, ttl = this.ttl) {
+        let value = await this.get(key);
+        if (value) {
+            return value;
+        }
+        value = await this.value(callback);
+        await this.put(key, value, ttl);
+        return value;
+    }
+    async rememberForever(key, callback) {
+        let value = await this.get(key);
+        if (value) {
+            return value;
+        }
+        value = await this.value(callback());
+        await this.forever(key, value);
+        return value;
+    }
+    async forget(key) {
+        const result = await this.store.forget(this.itemKey(key));
+        return result;
+    }
+    async flush() {
+        const result = await this.store.flush();
+        return result;
+    }
+    getDefaultCacheTime() {
+        return this.ttl;
+    }
+    setDefaultCacheTime(ttl) {
+        this.ttl = ttl;
+        return this;
+    }
+    getStore() {
+        return this.store;
+    }
+    setStore(store) {
+        this.store = store;
+        return this;
+    }
+    itemKey(key) {
+        return this.store.getPrefix() + key;
+    }
+    getSeconds(ttl) {
+        return ttl;
+    }
+    async value(value) {
+        return typeof value === 'function' ? await value() : value;
+    }
+}
+exports.Repo = Repo;

package/core/infrastructure/cache/stores/ArrayStore.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Store } from '../../../../core/domain/cache/Store';
+type CacheRecord<T> = {
+    data: T;
+    expire?: number;
+};
+export declare class ArrayStore implements Store {
+    protected readonly store: Map<string, CacheRecord<any>>;
+    protected readonly timeoutRefs: Map<string, NodeJS.Timeout>;
+    get<T>(key: string): Promise<T | null>;
+    put(key: string, value: unknown, ttl: number): Promise<boolean>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    getPrefix(): string;
+}
+export {};

package/core/infrastructure/cache/stores/ArrayStore.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayStore = void 0;
+class ArrayStore {
+    store = new Map();
+    timeoutRefs = new Map();
+    async get(key) {
+        const now = Date.now();
+        const record = this.store.get(key);
+        const expiration = record?.expire ?? Infinity;
+        if (!record || expiration < now) {
+            return null;
+        }
+        return record.data;
+    }
+    async put(key, value, ttl) {
+        const record = { data: value, expire: ttl * 1000 + Date.now() };
+        const oldRecord = this.store.get(key);
+        if (oldRecord) {
+            await this.forget(key);
+        }
+        const ref = setTimeout(async () => {
+            await this.forget(key);
+        }, ttl * 1000);
+        ref.unref();
+        this.timeoutRefs.set(key, ref);
+        this.store.set(key, record);
+        return true;
+    }
+    async forever(key, value) {
+        const record = { data: value };
+        const oldRecord = this.store.get(key);
+        if (oldRecord) {
+            await this.forget(key);
+        }
+        this.store.set(key, record);
+        return true;
+    }
+    async forget(key) {
+        let keys = [key];
+        if (key.includes('*')) {
+            const regExp = new RegExp(key.replace('*', '.*'));
+            keys = Array.from(this.store.keys()).filter((k) => k.match(regExp));
+        }
+        keys.forEach((key) => {
+            const timeoutRef = this.timeoutRefs.get(key);
+            if (timeoutRef) {
+                clearTimeout(timeoutRef);
+                this.timeoutRefs.delete(key);
+            }
+            this.store.delete(key);
+        });
+        return true;
+    }
+    async flush() {
+        this.timeoutRefs.forEach((ref) => clearTimeout(ref));
+        this.timeoutRefs.clear();
+        this.store.clear();
+        return true;
+    }
+    getPrefix() {
+        return '';
+    }
+}
+exports.ArrayStore = ArrayStore;

package/core/infrastructure/cache/stores/FileStore.d.ts

@@ -0,0 +1,14 @@
+import { Store } from '../../../../core/domain/cache/Store';
+export declare class FileStore implements Store {
+    protected directory: string;
+    constructor(directory: string);
+    get<T>(key: string): Promise<T | null>;
+    put(key: string, value: unknown, ttl: number): Promise<boolean>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    getPrefix(): string;
+    protected getPayload<T>(key: string): Promise<T | null>;
+    protected path(key: string): string;
+    protected ensureDirectoryExists(path: string): Promise<void>;
+}

package/core/infrastructure/cache/stores/FileStore.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = void 0;
+const promises_1 = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+class Hash {
+    static make(text) {
+        return (0, crypto_1.createHash)('sha256').update(text).digest('hex');
+    }
+}
+class File {
+    static async exists(path) {
+        try {
+            await promises_1.default.access(path, promises_1.constants.F_OK);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async mkdir(path) {
+        try {
+            await promises_1.default.mkdir(path, { recursive: true });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async read(path) {
+        try {
+            const value = await promises_1.default.readFile(path, 'utf-8');
+            return value ? JSON.parse(value) : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    static async store(path, data) {
+        try {
+            const json = JSON.stringify(data);
+            await promises_1.default.writeFile(path, json, 'utf-8');
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async delete(path) {
+        try {
+            await promises_1.default.unlink(path);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async rm(path) {
+        try {
+            await promises_1.default.rm(path, { recursive: true, force: true });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+class FileStore {
+    directory;
+    constructor(directory) {
+        this.directory = path_1.default.resolve(directory);
+    }
+    async get(key) {
+        return await this.getPayload(key);
+    }
+    async put(key, value, ttl) {
+        const record = { data: value, expire: ttl * 1000 + Date.now() };
+        try {
+            const path = this.path(key);
+            await this.ensureDirectoryExists(path);
+            await File.store(path, record);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async forever(key, value) {
+        const record = { data: value };
+        try {
+            const path = this.path(key);
+            await this.ensureDirectoryExists(path);
+            await File.store(path, record);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async forget(key) {
+        try {
+            const path = this.path(key);
+            await File.delete(path);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async flush() {
+        try {
+            await File.rm(this.directory);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getPrefix() {
+        return '';
+    }
+    async getPayload(key) {
+        const path = this.path(key);
+        let now = Date.now();
+        let record = await File.read(path);
+        const expiration = record?.expire ?? Infinity;
+        if (!record || expiration < now) {
+            await this.forget(key);
+            return null;
+        }
+        return record.data;
+    }
+    path(key) {
+        const hash = Hash.make(key);
+        const parts = hash.match(/.{2}/g).slice(0, 2);
+        return path_1.default.join(this.directory, ...parts, hash);
+    }
+    async ensureDirectoryExists(path) {
+        const directory = path_1.default.dirname(path);
+        if (!await File.exists(directory)) {
+            await File.mkdir(directory);
+        }
+    }
+}
+exports.FileStore = FileStore;

package/core/infrastructure/cache/stores/NullStore.d.ts

@@ -0,0 +1,9 @@
+import { Store } from '../../../../core/domain/cache/Store';
+export declare class NullStore implements Store {
+    get<T>(key: string): Promise<T | null>;
+    put(key: string, value: any, ttl: number): Promise<boolean>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    getPrefix(): string;
+}

package/core/infrastructure/cache/stores/NullStore.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullStore = void 0;
+class NullStore {
+    async get(key) {
+        return null;
+    }
+    async put(key, value, ttl) {
+        return false;
+    }
+    async forever(key, value) {
+        return false;
+    }
+    async forget(key) {
+        return false;
+    }
+    async flush() {
+        return false;
+    }
+    getPrefix() {
+        return '';
+    }
+}
+exports.NullStore = NullStore;

package/core/infrastructure/cache/stores/RedisStore.d.ts

@@ -0,0 +1,13 @@
+import { Store } from '../../../../core/domain/cache/Store';
+import { Redis } from 'ioredis';
+export declare class RedisStore implements Store {
+    protected readonly redis: Redis;
+    protected readonly prefix: string;
+    constructor(redis: Redis, prefix?: string);
+    get<T>(key: string): Promise<T | null>;
+    put(key: string, value: unknown, ttl: number): Promise<boolean>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    getPrefix(): string;
+}

package/core/infrastructure/cache/stores/RedisStore.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStore = void 0;
+class RedisStore {
+    redis;
+    prefix;
+    constructor(redis, prefix = '') {
+        this.redis = redis;
+        this.prefix = prefix;
+    }
+    async get(key) {
+        try {
+            const value = await this.redis.get(key);
+            if (value) {
+                return JSON.parse(value);
+            }
+        }
+        catch (error) {
+            await this.forget(key);
+        }
+        return null;
+    }
+    async put(key, value, ttl) {
+        return !!await this.redis.set(key, JSON.stringify(value), 'EX', ttl);
+    }
+    async forever(key, value) {
+        return !!await this.redis.set(key, JSON.stringify(value));
+    }
+    async forget(key) {
+        const keys = await this.redis.keys(key);
+        const pipeline = this.redis.pipeline();
+        keys.forEach((key) => {
+            pipeline.del(key);
+        });
+        return !!await pipeline.exec();
+    }
+    async flush() {
+        return await this.forget('*');
+    }
+    getPrefix() {
+        return this.prefix;
+    }
+}
+exports.RedisStore = RedisStore;

package/core/infrastructure/events/ChannelEvent.d.ts

@@ -0,0 +1,9 @@
+import { ChannelWrapper } from 'amqp-connection-manager';
+type ChannelType = 'publisher' | 'default';
+export declare class ChannelEvent {
+    private static channels;
+    private constructor();
+    private static createChannel;
+    static getChannel(channelType?: ChannelType): ChannelWrapper;
+}
+export {};

package/core/infrastructure/events/ChannelEvent.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelEvent = void 0;
+const Connection_1 = require("./Connection");
+const logger_1 = __importDefault(require("../../../core/utils/logger"));
+class ChannelEvent {
+    static channels = {
+        default: null,
+        publisher: null
+    };
+    constructor() {
+        //
+    }
+    static createChannel(channelType = 'default') {
+        const connection = channelType === 'default'
+            ? Connection_1.Connection.getConnection('default')
+            : Connection_1.Connection.getConnection('publisher');
+        const channel = connection.createChannel({ json: true });
+        channel.on('error', (err) => {
+            logger_1.default.error('AMQP channel error:', { msg: err.message, stack: err.stack });
+            this.channels[channelType] = null;
+        });
+        channel.on('close', () => {
+            logger_1.default.error('AMQP channel error:', { msg: 'closed' });
+            this.channels[channelType] = null;
+        });
+        this.channels[channelType] = channel;
+        return channel;
+    }
+    static getChannel(channelType = 'default') {
+        return this.channels[channelType] ?? this.createChannel(channelType);
+    }
+}
+exports.ChannelEvent = ChannelEvent;

package/core/infrastructure/events/Connection.d.ts

@@ -0,0 +1,8 @@
+import { AmqpConnectionManager, Channel, ChannelWrapper } from 'amqp-connection-manager';
+export { Channel, ChannelWrapper };
+export declare class Connection {
+    private static connections;
+    private constructor();
+    private static createConnection;
+    static getConnection(connectionType?: string): AmqpConnectionManager;
+}

package/core/infrastructure/events/Connection.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const amqp_connection_manager_1 = __importDefault(require("amqp-connection-manager"));
+const logger_1 = __importDefault(require("../../../core/utils/logger"));
+class Connection {
+    static connections = {};
+    constructor() {
+        //
+    }
+    static createConnection(connectionType = 'default') {
+        const connection = amqp_connection_manager_1.default.connect([process.env.APP_MQ]);
+        connection.on('connect', () => {
+            logger_1.default.debug('Connection established successfully.', { connectionType });
+        });
+        connection.on('disconnect', (params) => {
+            logger_1.default.warn('Connection lost. ', { connectionType, reason: params.err.message });
+            this.connections[connectionType] = null;
+        });
+        this.connections[connectionType] = connection;
+        return connection;
+    }
+    static getConnection(connectionType = 'default') {
+        return this.connections[connectionType] ?? this.createConnection(connectionType);
+    }
+}
+exports.Connection = Connection;

package/core/infrastructure/events/Event.d.ts

@@ -0,0 +1,16 @@
+import { Event as EventContract } from "../../../core/domain/events/Event";
+import { AmqpConnectionManager, Channel, ChannelWrapper } from "amqp-connection-manager";
+export { Channel, ChannelWrapper };
+export declare abstract class Event<T> implements EventContract {
+    protected connection: AmqpConnectionManager;
+    protected channel: ChannelWrapper;
+    protected priority: number;
+    protected payload: T;
+    abstract exchange: string;
+    abstract topic: string;
+    constructor(payload: T);
+    init(): this;
+    protected setup(channel: Channel): void;
+    publish(options?: {}): Promise<boolean>;
+    publishWithoutPersistence(options?: {}): Promise<boolean>;
+}

package/core/infrastructure/events/Event.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const core_1 = require("../../../core");
+const Connection_1 = require("./Connection");
+const ChannelEvent_1 = require("./ChannelEvent");
+class Event {
+    connection;
+    channel;
+    priority;
+    payload;
+    constructor(payload) {
+        this.connection = Connection_1.Connection.getConnection("publisher");
+        this.payload = payload;
+        this.priority = 0;
+    }
+    init() {
+        this.channel = ChannelEvent_1.ChannelEvent.getChannel("publisher");
+        this.channel.addSetup(this.setup.bind(this));
+        return this;
+    }
+    setup(channel) {
+        channel.assertExchange(this.exchange, "topic", { durable: false });
+    }
+    async publish(options = {}) {
+        core_1.logger.debug("Publish message %s", this.constructor.name);
+        const result = await this.channel.publish(this.exchange, this.topic, this.payload, Object.assign({
+            deliveryMode: 2,
+            persistent: true,
+        }, options));
+        return result;
+    }
+    async publishWithoutPersistence(options = {}) {
+        core_1.logger.debug("Publish message %s", this.constructor.name);
+        const result = await this.channel.publish(this.exchange, this.topic, this.payload, Object.assign({
+            deliveryMode: 1,
+            persistent: false,
+        }, options));
+        return result;
+    }
+}
+exports.Event = Event;

package/core/infrastructure/events/Listener.d.ts

@@ -0,0 +1,23 @@
+import { Listener as ListenerContract } from '../../../core/domain/events/Listener';
+import { AmqpConnectionManager, Channel, ChannelWrapper } from 'amqp-connection-manager';
+import { Connection } from './Connection';
+export { Channel, ChannelWrapper, Connection };
+export declare abstract class Listener<T> implements ListenerContract {
+    protected static instance: Listener<any>;
+    protected connection: AmqpConnectionManager;
+    protected channel: ChannelWrapper;
+    protected service: string;
+    protected extraQueues: any;
+    abstract exchange: string;
+    abstract topic: string;
+    protected exclusiveConnection: boolean;
+    constructor();
+    init(): this;
+    protected setup(channel: Channel): void;
+    protected setupExtraQueue(channel: Channel, suffixes?: string[]): void;
+    abstract onMessage(data: T, ack: Function, nack?: Function): any;
+    listen(): Promise<import("amqplib").Replies.Consume>;
+    get queue(): string;
+    get connectionName(): string;
+    protected parseMessage(msg: any): any;
+}