@aptana/multichannel-common 2.9.12

package/core/domain/Command.d.ts

@@ -0,0 +1,3 @@
+export interface Command {
+    execute(): void;
+}

package/core/domain/Command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/Entity.d.ts

@@ -0,0 +1,6 @@
+import { UniqueId } from '../../core/domain/UniqueId';
+export declare abstract class Entity<T> {
+    protected readonly _id: UniqueId;
+    protected readonly props: T;
+    constructor(props: T, id?: UniqueId);
+}

package/core/domain/Entity.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const UniqueId_1 = require("../../core/domain/UniqueId");
+class Entity {
+    _id;
+    props;
+    constructor(props, id) {
+        this._id = id ?? new UniqueId_1.UniqueId();
+        this.props = props;
+    }
+}
+exports.Entity = Entity;

package/core/domain/Identifier.d.ts

@@ -0,0 +1,5 @@
+export declare class Identifier<T> {
+    private value;
+    constructor(value: T);
+    toString(): string;
+}

package/core/domain/Identifier.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identifier = void 0;
+class Identifier {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return String(this.value);
+    }
+}
+exports.Identifier = Identifier;

package/core/domain/UniqueId.d.ts

@@ -0,0 +1,4 @@
+import { Identifier } from '../../core/domain/Identifier';
+export declare class UniqueId extends Identifier<string> {
+    constructor(id?: string);
+}

package/core/domain/UniqueId.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueId = void 0;
+const node_crypto_1 = require("node:crypto");
+const Identifier_1 = require("../../core/domain/Identifier");
+class UniqueId extends Identifier_1.Identifier {
+    constructor(id) {
+        super(id ?? (0, node_crypto_1.randomUUID)());
+    }
+}
+exports.UniqueId = UniqueId;

package/core/domain/UseCase.d.ts

@@ -0,0 +1,3 @@
+export interface UseCase<Request, Response> {
+    execute(req?: Request): Response;
+}

package/core/domain/UseCase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/ValueObject.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class ValueObject<T> {
+    readonly props: T;
+    constructor(props: T);
+}

package/core/domain/ValueObject.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObject = void 0;
+class ValueObject {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+}
+exports.ValueObject = ValueObject;

package/core/domain/auth/Auth.d.ts

@@ -0,0 +1,17 @@
+import TokenGuard from './TokenGuard';
+import UserProvider from './UserProvider';
+/**
+ * @deprecated
+ */
+export declare class Auth {
+    private static _instance;
+    private _provider;
+    private _request;
+    private constructor();
+    static getInstance(): Auth;
+    static guard(): TokenGuard;
+    setUserProvider(provider: UserProvider): this;
+    setRequest(request: any): this;
+    private tokenGuard;
+}
+export default Auth;

package/core/domain/auth/Auth.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const TokenGuard_1 = __importDefault(require("./TokenGuard"));
+/**
+ * @deprecated
+ */
+class Auth {
+    static _instance;
+    _provider;
+    _request;
+    constructor() {
+        //
+    }
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new Auth();
+        }
+        return this._instance;
+    }
+    static guard() {
+        return Auth.getInstance()
+            .tokenGuard();
+    }
+    setUserProvider(provider) {
+        this._provider = provider;
+        return this;
+    }
+    setRequest(request) {
+        this._request = request;
+        return this;
+    }
+    tokenGuard() {
+        return new TokenGuard_1.default(this._provider, this._request);
+    }
+}
+exports.Auth = Auth;
+exports.default = Auth;

package/core/domain/auth/Authenticable.d.ts

@@ -0,0 +1,4 @@
+import User from "../../../domain/User";
+export interface Authenticable extends User {
+}
+export default Authenticable;

package/core/domain/auth/Authenticable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/auth/Guard.d.ts

@@ -0,0 +1,20 @@
+import Authenticable from './Authenticable';
+export interface Guard {
+    /**
+     * Determine if the current user is authenticated.
+     */
+    check(): Promise<boolean>;
+    /**
+     * Determine if the current user is a guest.
+     */
+    guest(): Promise<boolean>;
+    /**
+     * Set the current user.
+     */
+    setUser(user: Authenticable): Promise<void>;
+    /**
+     * Get the currently authenticated user.
+     */
+    user(): Promise<Authenticable | null>;
+}
+export default Guard;

package/core/domain/auth/Guard.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/auth/TokenGuard.d.ts

@@ -0,0 +1,33 @@
+import Authenticable from './Authenticable';
+import Guard from './Guard';
+import UserProvider from './UserProvider';
+export declare class TokenGuard implements Guard {
+    /**
+     * The request instance.
+     */
+    private _req;
+    /**
+     * The user provider implementation.
+     */
+    private _provider;
+    /**
+     * The currently authenticated user.
+     */
+    private _user;
+    /**
+     * Create a new authtentication guard.
+     */
+    constructor(provider: UserProvider, req: any);
+    /**
+     * Determine if the current user is authenticated. If not, throw an error.
+     */
+    authenticate(): Promise<Authenticable>;
+    check(): Promise<boolean>;
+    guest(): Promise<boolean>;
+    setUser(user: Authenticable): Promise<void>;
+    setRequest(req: any): Promise<void>;
+    user(): Promise<Authenticable | null>;
+    private getTokenFromRequest;
+    private getUserKeyTokenFromRequest;
+}
+export default TokenGuard;

package/core/domain/auth/TokenGuard.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenGuard = void 0;
+const WrongCredentialsError_1 = __importDefault(require("../../../core/errors/WrongCredentialsError"));
+class TokenGuard {
+    /**
+     * The request instance.
+     */
+    _req;
+    /**
+     * The user provider implementation.
+     */
+    _provider;
+    /**
+     * The currently authenticated user.
+     */
+    _user;
+    /**
+     * Create a new authtentication guard.
+     */
+    constructor(provider, req) {
+        this._provider = provider;
+        this._req = req;
+    }
+    /**
+     * Determine if the current user is authenticated. If not, throw an error.
+     */
+    async authenticate() {
+        const user = await this.user();
+        if (user) {
+            return user;
+        }
+        throw new WrongCredentialsError_1.default();
+    }
+    async check() {
+        return !!(await this.user());
+    }
+    async guest() {
+        return !(await this.check);
+    }
+    async setUser(user) {
+        // this._user = user;
+    }
+    async setRequest(req) {
+        this._req = req;
+    }
+    async user() {
+        // if (this._user) {
+        //   return this._user;
+        // }
+        let user = null;
+        let token = this.getTokenFromRequest();
+        let { userKey, userToken } = this.getUserKeyTokenFromRequest();
+        if (token) {
+            user = await this._provider.getByToken(token);
+        }
+        if (userKey && userToken) {
+            user = await this._provider.getByUserKeyAndUserToken(userKey, userToken);
+        }
+        return user;
+        // return this._user = user!;
+    }
+    getTokenFromRequest() {
+        let token = this._req.query['api_token'];
+        if (!token) {
+            token = this._req.body['api_token'];
+        }
+        if (!token && this._req.header('API-Token')) {
+            token = this._req.header('API-Token');
+        }
+        if (!token && this._req.header('Authorization')) {
+            const authorization = this._req.header('Authorization');
+            let [_, bearerToken] = authorization.split(' ');
+            token = bearerToken;
+        }
+        return token;
+    }
+    getUserKeyTokenFromRequest() {
+        let userKey = this._req.query['userkey'];
+        let userToken = this._req.query['usertoken'];
+        if (!userKey) {
+            userKey = this._req.body['userkey'];
+        }
+        if (!userToken) {
+            userToken = this._req.body['usertoken'];
+        }
+        return { userKey, userToken };
+    }
+}
+exports.TokenGuard = TokenGuard;
+exports.default = TokenGuard;

package/core/domain/auth/UserProvider.d.ts

@@ -0,0 +1,17 @@
+import Authenticable from './Authenticable';
+export interface UserProvider {
+    /**
+     * Get user by their unique identifier.
+     */
+    getById(id: any): Promise<Authenticable | null>;
+    /**
+     * Get user by their api token.
+     */
+    getByToken(token: string): Promise<Authenticable | null>;
+    /**
+     * Get user by the given credentials.
+     */
+    getByCredentials(credentials: object): Promise<Authenticable | null>;
+    getByUserKeyAndUserToken(userKey: string, userToken: string): Promise<Authenticable | null>;
+}
+export default UserProvider;

package/core/domain/auth/UserProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/cache/Cache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated
+ */
+export interface Cache {
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, data: unknown, ttl?: number): Promise<void>;
+    invalidate(key: string): Promise<void>;
+}

package/core/domain/cache/Cache.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,51 @@
+import { Store } from '../../../core/domain/cache/Store';
+export interface Repo {
+    /**
+     * Determine if an item exists in the cache.
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Determine if an item doesn't exist in the cache.
+     */
+    missing(key: string): Promise<boolean>;
+    /**
+     * Retrieve an item from the cache by key.
+     */
+    get<T>(key: string, _default?: unknown): Promise<T | null>;
+    /**
+     * Retrieve an item from the cache and delete it.
+     */
+    pull<T>(key: string, _default?: unknown): Promise<T | null>;
+    /**
+     * Store an item in the cache.
+     */
+    put(key: string, value: unknown, ttl?: number): Promise<boolean>;
+    /**
+     * Store an item in the cache if the key does not exist.
+     */
+    add(key: string, value: unknown, ttl?: number): Promise<boolean>;
+    /**
+     * Store an item in the cache indefinitely.
+     */
+    forever(key: string, value: unknown): Promise<boolean>;
+    /**
+     * Get an item from the cache, or execute the given Closure and store the result.
+     */
+    remember<T>(key: string, callback: Function, ttl?: number): Promise<T>;
+    /**
+     * Get an item from the cache, or execute the given Closure and store the result forever.
+     */
+    rememberForever<T>(key: string, callback: Function): Promise<T>;
+    /**
+     * Remove an item from the cache.
+     */
+    forget(key: string): Promise<boolean>;
+    /**
+     * Remove all items from the cache.
+     */
+    flush(): Promise<boolean>;
+    /**
+     * Get the cache store implementation.
+     */
+    getStore(): Store;
+}

package/core/domain/cache/Repo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/cache/Store.d.ts

@@ -0,0 +1,26 @@
+export interface Store {
+    /**
+     *  Fetches a value from the cache.
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Store an item in the cache for a given number of seconds.
+     */
+    put(key: string, value: unknown, ttl: number): Promise<boolean>;
+    /**
+     * Store an item in the cache indefinitely.
+     */
+    forever(key: string, value: unknown): Promise<boolean>;
+    /**
+     * Remove an item from the cache.
+     */
+    forget(key: string): Promise<boolean>;
+    /**
+     * Remove all items from the cache.
+     */
+    flush(): Promise<boolean>;
+    /**
+     * Get the cache key prefix.
+     */
+    getPrefix(): string;
+}

package/core/domain/cache/Store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+export interface EventOptions {
+    [key: string]: unknown;
+}
+export interface Event {
+    init(): Event;
+    publish(options?: EventOptions): any;
+    publishWithoutPersistence?(options?: EventOptions): any;
+}

package/core/domain/events/Event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+export interface Listener {
+    init(): Listener;
+    listen(): any;
+}

package/core/domain/events/Listener.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/events/Worker.d.ts

@@ -0,0 +1,3 @@
+export interface Worker {
+    start(): void;
+}

package/core/domain/events/Worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/loaders/Loader.d.ts

@@ -0,0 +1,4 @@
+export interface Loader {
+    load(): void;
+    register(): void;
+}

package/core/domain/loaders/Loader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/domain/loaders/Manager.d.ts

@@ -0,0 +1,3 @@
+export interface Manager {
+    load(): void;
+}

package/core/domain/loaders/Manager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/errors/AppError.d.ts

@@ -0,0 +1,10 @@
+export interface ErrorMessage {
+    message: string;
+    field?: string;
+}
+export declare class AppError extends Error {
+    status: number;
+    message: string;
+    constructor(message: string, status?: number);
+    serializeErrors(): ErrorMessage[];
+}

package/core/errors/AppError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+class AppError extends Error {
+    status;
+    message;
+    constructor(message, status = 500) {
+        super(message);
+        this.message = message;
+        this.status = status;
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.AppError = AppError;

package/core/errors/AuthenticationTokenMissingError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class AuthenticationTokenMissingError extends AppError {
+    constructor();
+}
+export default AuthenticationTokenMissingError;

package/core/errors/AuthenticationTokenMissingError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationTokenMissingError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class AuthenticationTokenMissingError extends AppError_1.AppError {
+    constructor() {
+        super('Authentication token missing', 401);
+    }
+}
+exports.AuthenticationTokenMissingError = AuthenticationTokenMissingError;
+exports.default = AuthenticationTokenMissingError;

package/core/errors/BadRequestError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class BadRequestError extends AppError {
+    constructor(message?: string);
+}
+export default BadRequestError;

package/core/errors/BadRequestError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class BadRequestError extends AppError_1.AppError {
+    constructor(message = 'Bad Request') {
+        super(message, 400);
+    }
+}
+exports.BadRequestError = BadRequestError;
+exports.default = BadRequestError;

package/core/errors/NotAuthorizedError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class NotAuthorizedError extends AppError {
+    constructor();
+}
+export default NotAuthorizedError;

package/core/errors/NotAuthorizedError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class NotAuthorizedError extends AppError_1.AppError {
+    constructor() {
+        super('You\'re not authorized', 403);
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;
+exports.default = NotAuthorizedError;

package/core/errors/NotFoundError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class NotFoundError extends AppError {
+    constructor(message?: string);
+}
+export default NotFoundError;

package/core/errors/NotFoundError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class NotFoundError extends AppError_1.AppError {
+    constructor(message = 'Not Found') {
+        super(message, 404);
+    }
+}
+exports.NotFoundError = NotFoundError;
+exports.default = NotFoundError;

package/core/errors/RequestValidationError.d.ts

@@ -0,0 +1,10 @@
+import { ValidationError } from 'class-validator';
+import { AppError, ErrorMessage } from '../../core/errors/AppError';
+export declare class RequestValidationError extends AppError {
+    protected errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+    serializeErrors(): ErrorMessage[];
+    private mapChildrenToValidationErrors;
+    private prependConstraintsWithParentProp;
+}
+export default RequestValidationError;