pangea-server 1.0.1

package/README.md

@@ -0,0 +1 @@
+# PANGEA BACKEND

package/dist/authentication/access-token.class.d.ts

@@ -0,0 +1,13 @@
+import { User } from '../database';
+import type { UserCtor } from './authentication.types';
+export declare class AccessToken {
+    private __privateKey;
+    constructor(privateKey: string);
+    getKey(userCtor: UserCtor): string;
+    createToken(userCtor: UserCtor, id: ModelId): string;
+    verifyToken(token: string): Record<string, number>;
+    getTokenData(userCtor: UserCtor, user: User): {
+        accessToken: string;
+        user: User;
+    };
+}

package/dist/authentication/access-token.class.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+// helpers
+const pangea_helpers_1 = require("pangea-helpers");
+class AccessToken {
+    constructor(privateKey) {
+        this.__privateKey = privateKey;
+    }
+    getKey(userCtor) {
+        return `${(0, pangea_helpers_1.getFirstChartInLowercase)(userCtor.name)}Id`;
+    }
+    createToken(userCtor, id) {
+        const key = this.getKey(userCtor);
+        return jsonwebtoken_1.default.sign({ [key]: id }, this.__privateKey, { expiresIn: 60 * 60 * 24 * 365 });
+    }
+    verifyToken(token) {
+        return jsonwebtoken_1.default.verify(token, this.__privateKey);
+    }
+    getTokenData(userCtor, user) {
+        return { accessToken: this.createToken(userCtor, user.id), user };
+    }
+}
+exports.AccessToken = AccessToken;

package/dist/authentication/authentication.helpers.d.ts

@@ -0,0 +1,17 @@
+import { AccessToken } from './access-token.class';
+import { User } from '../database';
+import type { UserCtor, AuthMap } from './authentication.types';
+type AuthHeader = string | undefined;
+export declare function login(authHeader: AuthHeader, tx: Tx, accessToken: AccessToken, userCtor: UserCtor): Promise<{
+    accessToken: string;
+    user: User;
+}>;
+export declare function validateAccessToken(authHeader: AuthHeader, tx: Tx, accessToken: AccessToken, userCtor: UserCtor): Promise<{
+    accessToken: string;
+    user: User;
+}>;
+export declare function getUserFromToken(authHeader: AuthHeader, tx: Tx, accessToken: AccessToken, userCtor: UserCtor): Promise<User | null> | null;
+export declare function getUsersFromToken(authHeader: AuthHeader, tx: Tx, accessToken: AccessToken, authMap: AuthMap): Promise<{
+    [k: string]: User | null;
+}>;
+export {};

package/dist/authentication/authentication.helpers.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsersFromToken = exports.getUserFromToken = exports.validateAccessToken = exports.login = void 0;
+// helpers
+const helpers_1 = require("../helpers");
+// database
+const database_1 = require("../database");
+async function login(authHeader, tx, accessToken, userCtor) {
+    if (!authHeader?.startsWith('Basic '))
+        helpers_1.AppError.ThrowInvalidCredentials();
+    const base64 = authHeader.slice(6);
+    const decoded = Buffer.from(base64, 'base64').toString('utf-8');
+    const [username, password] = decoded.split(':');
+    if (!username || !password)
+        helpers_1.AppError.ThrowInvalidCredentials();
+    const db = new database_1.Db(tx);
+    const user = await db.findOneOrNull(userCtor, { username }, { scopes: ['withExcludedAttributes'] });
+    if (!user)
+        helpers_1.AppError.ThrowInvalidCredentials();
+    const isPasswordValid = await (0, helpers_1.comparePasswords)(password, user.password);
+    if (!isPasswordValid)
+        helpers_1.AppError.ThrowInvalidCredentials();
+    return accessToken.getTokenData(userCtor, user);
+}
+exports.login = login;
+async function validateAccessToken(authHeader, tx, accessToken, userCtor) {
+    const user = await getUserFromToken(authHeader, tx, accessToken, userCtor);
+    if (!user)
+        helpers_1.AppError.ThrowUnauthorized();
+    return accessToken.getTokenData(userCtor, user);
+}
+exports.validateAccessToken = validateAccessToken;
+function getUserFromToken(authHeader, tx, accessToken, userCtor) {
+    try {
+        const token = getBearerToken(authHeader);
+        const payload = accessToken.verifyToken(token);
+        const key = accessToken.getKey(userCtor);
+        const id = payload[key];
+        if (!id)
+            return null;
+        const db = new database_1.Db(tx);
+        return db.findOneOrNull(userCtor, id);
+    }
+    catch {
+        return null;
+    }
+}
+exports.getUserFromToken = getUserFromToken;
+async function getUsersFromToken(authHeader, tx, accessToken, authMap) {
+    try {
+        const token = getBearerToken(authHeader);
+        const payload = accessToken.verifyToken(token);
+        const results = await Promise.all(Object.entries(authMap).map(async ([type, userCtor]) => {
+            const key = accessToken.getKey(userCtor);
+            const id = payload[key];
+            if (!id)
+                return [type, null];
+            const db = new database_1.Db(tx);
+            const user = await db.findOneOrNull(userCtor, id);
+            return [type, user];
+        }));
+        return Object.fromEntries(results);
+    }
+    catch {
+        return Object.fromEntries(Object.keys(authMap).map((type) => [type, null]));
+    }
+}
+exports.getUsersFromToken = getUsersFromToken;
+// internal functions
+function getBearerToken(authHeader) {
+    if (!authHeader)
+        throw new Error('Missing authorization header');
+    const [type, token] = authHeader.split(' ');
+    if (type !== 'Bearer' || !token)
+        throw new Error('Invalid authorization format');
+    return token;
+}

package/dist/authentication/authentication.types.d.ts

@@ -0,0 +1,11 @@
+import { BaseAuth } from './base-auth.class';
+import { User } from '../database';
+export type UserCtor = BaseModelCtor<User>;
+export type AuthMap = Record<string, UserCtor>;
+export type UserType<AM extends AuthMap> = keyof AM;
+export type AuthUsers<AM extends AuthMap> = {
+    [K in keyof AM]: InstanceType<AM[K]> | null;
+};
+export interface AuthCtor<AM extends AuthMap, AU extends AuthUsers<AM>, BA extends BaseAuth<AM>> {
+    new (authUsers: AU): BA;
+}

package/dist/authentication/authentication.types.js

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

package/dist/authentication/base-auth.class.d.ts

@@ -0,0 +1,9 @@
+import type { AuthMap, UserType, AuthUsers } from './authentication.types';
+export declare abstract class BaseAuth<AM extends AuthMap> {
+    private __authUsers;
+    constructor(authUsers: AuthUsers<AM>);
+    free(): void;
+    notSetYet(): void;
+    isUserAuth<T extends UserType<AM>>(type: T): NonNullable<AuthUsers<AM>[T]>;
+    isAnyUserAuth<const T extends readonly UserType<AM>[]>(types: T): { [I in keyof T]: InstanceType<AM[T[I]]> | null; };
+}

package/dist/authentication/base-auth.class.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAuth = void 0;
+// helpers
+const helpers_1 = require("../helpers");
+class BaseAuth {
+    constructor(authUsers) {
+        this.__authUsers = authUsers;
+    }
+    free() {
+        (0, helpers_1.printWarning)('authentication', 'free access');
+    }
+    notSetYet() {
+        (0, helpers_1.printWarning)('authentication', 'auth not set yet');
+    }
+    isUserAuth(type) {
+        const user = this.__authUsers[type];
+        if (!user)
+            helpers_1.AppError.ThrowUnauthorized();
+        return user;
+    }
+    isAnyUserAuth(types) {
+        const users = types.map((type) => this.__authUsers[type]);
+        if (users.every((user) => !user))
+            helpers_1.AppError.ThrowUnauthorized();
+        return users;
+    }
+}
+exports.BaseAuth = BaseAuth;

package/dist/authentication/index.d.ts

@@ -0,0 +1,4 @@
+export * from './access-token.class';
+export * from './authentication.helpers';
+export * from './authentication.types';
+export * from './base-auth.class';

package/dist/authentication/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./access-token.class"), exports);
+__exportStar(require("./authentication.helpers"), exports);
+__exportStar(require("./authentication.types"), exports);
+__exportStar(require("./base-auth.class"), exports);

package/dist/database/base-service.class.d.ts

@@ -0,0 +1,15 @@
+import { Db } from './db.class';
+import { BaseModel } from './models';
+type SetArrayConfig<T extends BaseModel, M extends BaseModel> = {
+    instances: T[];
+    getManyFn: (ids: number[]) => Promise<M[]>;
+    keyName: string;
+    relationName: string;
+};
+export declare abstract class BaseService {
+    protected tx: Tx;
+    protected db: Db;
+    constructor(tx: Tx);
+    protected __setArray<T extends BaseModel, M extends BaseModel>(config: SetArrayConfig<T, M>): Promise<void>;
+}
+export {};

package/dist/database/base-service.class.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const db_class_1 = require("./db.class");
+class BaseService {
+    constructor(tx) {
+        this.tx = tx;
+        this.db = new db_class_1.Db(tx);
+    }
+    async __setArray(config) {
+        const { instances, getManyFn, keyName, relationName } = config;
+        if (!instances.length)
+            return;
+        const instanceIds = instances.map((instance) => instance.id);
+        const instancesToSet = await getManyFn(instanceIds);
+        const instancesToSetMap = new Map();
+        for (const instanceToSet of instancesToSet) {
+            const key = instanceToSet[keyName];
+            const list = instancesToSetMap.get(key) || [];
+            list.push(instanceToSet);
+            instancesToSetMap.set(key, list);
+        }
+        for (const instance of instances) {
+            instance[relationName] = instancesToSetMap.get(instance.id) || [];
+        }
+    }
+}
+exports.BaseService = BaseService;

package/dist/database/database.helpers.d.ts

@@ -0,0 +1,4 @@
+import type { Transaction } from 'sequelize';
+export declare function startTransaction(): Promise<Transaction>;
+export declare function disableForeignKeyChecks(t?: Transaction): Promise<[unknown[], unknown]>;
+export declare function enableForeignKeyChecks(t?: Transaction): Promise<[unknown[], unknown]>;

package/dist/database/database.helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableForeignKeyChecks = exports.disableForeignKeyChecks = exports.startTransaction = void 0;
+const init_database_1 = require("./init-database");
+function startTransaction() {
+    const dbClient = (0, init_database_1.getDbClient)();
+    return dbClient.transaction();
+}
+exports.startTransaction = startTransaction;
+function disableForeignKeyChecks(t) {
+    const dbClient = (0, init_database_1.getDbClient)();
+    return dbClient.query('SET FOREIGN_KEY_CHECKS = 0', { transaction: t });
+}
+exports.disableForeignKeyChecks = disableForeignKeyChecks;
+function enableForeignKeyChecks(t) {
+    const dbClient = (0, init_database_1.getDbClient)();
+    return dbClient.query('SET FOREIGN_KEY_CHECKS = 1', { transaction: t });
+}
+exports.enableForeignKeyChecks = enableForeignKeyChecks;

package/dist/database/database.types.d.ts

@@ -0,0 +1,59 @@
+import * as seq from 'sequelize-typescript';
+import { BaseModel } from './models';
+import type { OptionalFields, OptionalIfNullish } from 'pangea-helpers';
+import type { InferCreationAttributes, CreationOptional, NonAttribute, AbstractDataTypeConstructor, AbstractDataType, Transaction, WhereOptions } from 'sequelize';
+import type { ModelCtor } from 'sequelize-typescript';
+declare global {
+    type ModelId = number;
+    type ModelName = string;
+    type BaseModelCtor<BM extends BaseModel = BaseModel> = typeof BaseModel & ModelCtor<BM>;
+    type ColOptional<T> = CreationOptional<T>;
+    type ColExcluded<T> = T & {
+        __brand: 'excluded';
+    };
+    type ColVirtual<T> = NonAttribute<T>;
+    type Tx = Transaction;
+    type Where<BM extends BaseModel> = WhereOptions<BM> & Record<symbol, any>;
+    type InsertParams<BM extends BaseModel> = OptionalIfNullish<OptionalIfOptional<StripRelations<OptionalFields<IncludeExcluded<InferCreationAttributes<BM>>, keyof InferCreationAttributes<BM> & 'id'>>>>;
+    type UpdateParams<BM extends BaseModel> = Partial<InsertParams<BM>>;
+}
+export type Models = Record<ModelName, BaseModelCtor>;
+export type Seeds<M extends Models> = {
+    [T in keyof M]: InsertParams<InstanceType<M[T]>>[];
+};
+export type ConnectDatabase = () => void;
+export type DisconnectDatabase = () => void;
+export type Index = {
+    field?: string;
+    fields?: string[];
+    unique?: boolean;
+};
+export type ColumnType = keyof typeof seq.DataType | AbstractDataTypeConstructor | AbstractDataType;
+export type DefaultValue = unknown;
+export type ColGeneralOptions = {
+    nullable?: boolean;
+    defaultValue?: DefaultValue;
+    index?: boolean;
+    unique?: boolean;
+    exclude?: boolean;
+};
+export type ColVirtualGet = (this: any) => unknown;
+export type ColVirtualSet = (this: any, val: any) => void;
+export type ColVirtualOptions = {
+    get?: ColVirtualGet;
+    set?: ColVirtualSet;
+};
+export type GetModelFn = () => BaseModelCtor;
+type OptionalIfOptional<T> = {
+    [K in keyof T as undefined extends T[K] ? K : never]?: Exclude<T[K], undefined>;
+} & {
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+type IncludeExcluded<T> = {
+    [K in keyof T]-?: Exclude<T[K], undefined> extends ColExcluded<infer U> ? U : T[K];
+};
+type IsRelation<T> = NonNullable<T> extends BaseModel | Array<BaseModel> ? true : false;
+type StripRelations<T> = {
+    [K in keyof T as IsRelation<T[K]> extends true ? never : K]: T[K];
+};
+export {};

package/dist/database/database.types.js

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

package/dist/database/db-client.d.ts

@@ -0,0 +1,11 @@
+import { Sequelize } from 'sequelize-typescript';
+import type { Models, Seeds } from './database.types';
+type InitDatabaseConfig = {
+    logging?: boolean;
+};
+export declare function initDatabase<M extends Models>(models: M, seeds: Seeds<M>, config?: InitDatabaseConfig): {
+    connectDatabase: () => Promise<void>;
+    disconnectDatabase: () => Promise<void>;
+};
+export declare function getDbClient(): Sequelize;
+export {};

package/dist/database/db-client.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbClient = exports.initDatabase = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+// helpers
+const helpers_1 = require("../helpers");
+const seed_helpers_1 = require("./seed.helpers");
+let dbClient = undefined;
+function initDatabase(models, seeds, config = {}) {
+    if (dbClient)
+        throw new Error('DbClient instance has already been initialized');
+    dbClient = new sequelize_typescript_1.Sequelize({
+        dialect: 'mysql',
+        host: (0, helpers_1.getEnvStr)('DB_HOST'),
+        port: (0, helpers_1.getEnvInt)('DB_PORT'),
+        username: (0, helpers_1.getEnvStr)('DB_USERNAME'),
+        password: (0, helpers_1.getEnvStr)('DB_PASSWORD'),
+        database: (0, helpers_1.getEnvStr)('DB_DATABASE'),
+        pool: { max: 5, min: 0, acquire: 30000, idle: 10000 },
+        models: Object.values(models),
+        logging: config.logging ? logQuery : false,
+        benchmark: true,
+    });
+    async function connectDatabase() {
+        try {
+            const dbClient = getDbClient();
+            await dbClient.authenticate();
+            (0, helpers_1.printSuccess)('database', 'database connected');
+            if ((0, helpers_1.getEnvStr)('ENVIRONMENT') !== 'production') {
+                if ((0, helpers_1.getEnvBool)('DB_DROP_TABLES'))
+                    await (0, seed_helpers_1.dropTables)();
+                await (0, seed_helpers_1.syncTables)();
+                if ((0, helpers_1.getEnvBool)('DB_SEED_TABLES'))
+                    await (0, seed_helpers_1.seedTables)(models, seeds);
+            }
+        }
+        catch (err) {
+            (0, helpers_1.printDanger)('database', err);
+            throw err;
+        }
+    }
+    async function disconnectDatabase() {
+        try {
+            const dbClient = getDbClient();
+            await dbClient.close();
+            (0, helpers_1.printSuccess)('database', 'database disconnected');
+        }
+        catch (err) {
+            (0, helpers_1.printDanger)('database', err);
+        }
+    }
+    return { connectDatabase, disconnectDatabase };
+}
+exports.initDatabase = initDatabase;
+function getDbClient() {
+    if (!dbClient)
+        throw new Error('DbClient instance is not initialized');
+    return dbClient;
+}
+exports.getDbClient = getDbClient;
+// internal functions
+function logQuery(sql, timing) {
+    (0, helpers_1.printInfo)('query', sql);
+    if (!timing)
+        return;
+    const logFns = { success: helpers_1.printSuccess, warning: helpers_1.printWarning, danger: helpers_1.printDanger };
+    const level = timing <= 50 ? 'success' : timing <= 200 ? 'warning' : 'danger';
+    logFns[level]('timing', `${timing} ms`);
+}

package/dist/database/db.class.d.ts

@@ -0,0 +1,64 @@
+import { BaseModel } from './models';
+type AttributeField = string;
+type AttributeOp = 'COUNT' | 'SUM';
+type AttributeColumn = AttributeField | [AttributeOp, AttributeField];
+type AttributeAlias = string;
+type Attribute = [AttributeColumn, AttributeAlias];
+type IncludeItem = {
+    relation?: string;
+    active?: boolean;
+    include?: IncludeItem[];
+};
+type Filters<BM extends BaseModel> = ModelId | Where<BM>;
+type Group = string[];
+type Order = Record<string, 'asc' | 'desc'>;
+type FindOneOptions = {
+    scopes?: string[];
+    attributes?: Attribute[];
+    include?: IncludeItem[];
+    order?: Order;
+    paranoid?: boolean;
+};
+type FindManyOptions<BM extends BaseModel> = {
+    attributes?: Attribute[];
+    include?: IncludeItem[];
+    where?: Where<BM>;
+    searchFields?: string[];
+    search?: string | null;
+    group?: Group;
+    order?: Order;
+    page?: number | null;
+    pageSize?: number | null;
+    paranoid?: 'active' | 'all' | 'deleted';
+};
+type InsertManyOptions<BM extends BaseModel> = {
+    ignoreDuplicates?: boolean;
+    updateOnDuplicate?: (keyof BM)[];
+};
+type Target<BM extends BaseModel> = Filters<BM> | BM;
+export declare class Db {
+    private __tx?;
+    constructor(tx: Tx);
+    findOneOrNull<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<BM | null>;
+    findOne<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<BM>;
+    findMany<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyOptions<BM>): Promise<{
+        instances: BM[];
+        totalCount: number;
+    }>;
+    insertOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: InsertParams<BM>): Promise<BM>;
+    insertMany<BM extends BaseModel>(model: BaseModelCtor<BM>, data: InsertParams<BM>[], options?: InsertManyOptions<BM>): Promise<number>;
+    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>, params: UpdateParams<BM>): Promise<BM>;
+    updateMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>, params: UpdateParams<BM>): Promise<number>;
+    deleteOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
+    deleteMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
+    destroyOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
+    destroyMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
+    restoreOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM>;
+    restoreMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<void>;
+    private __getInstance;
+    private __deleteOne;
+    private __deleteMany;
+    enableForeignKeyChecks(): Promise<[unknown[], unknown]>;
+    disableForeignKeyChecks(): Promise<[unknown[], unknown]>;
+}
+export {};