apeframework 0.0.0-dev.4 → 0.0.0-dev.41

package/dist/db/Operator.d.ts

@@ -0,0 +1,2 @@
+import { Op } from 'sequelize';
+export { Op as Operator, };

package/dist/db/Operator.js

@@ -0,0 +1,2 @@
+import { Op } from 'sequelize';
+export { Op as Operator, };

package/dist/db/Order.d.ts

@@ -0,0 +1,2 @@
+import type { Order } from 'sequelize';
+export { type Order, };

package/dist/db/Order.js

@@ -0,0 +1 @@
+export {};

package/dist/db/ReferentialAction.d.ts

@@ -0,0 +1,7 @@
+declare const ReferentialAction: {
+    CASCADE: string;
+    RESTRICT: string;
+    SET_DEFAULT: string;
+    SET_NULL: string;
+};
+export { ReferentialAction, };

package/dist/db/ReferentialAction.js

@@ -0,0 +1,7 @@
+const ReferentialAction = {
+    CASCADE: 'CASCADE',
+    RESTRICT: 'RESTRICT',
+    SET_DEFAULT: 'SET DEFAULT',
+    SET_NULL: 'SET NULL',
+};
+export { ReferentialAction, };

package/dist/db/Transaction.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from 'sequelize';
+export { type Transaction, };

package/dist/db/Transaction.js

@@ -0,0 +1 @@
+export {};

package/dist/db/adapters/maria/MariaDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class MariaDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { MariaDb, };

package/dist/db/adapters/maria/MariaDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MariaDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'mariadb',
+                dialectOptions: {
+                    ssl: typeof params.tls === 'boolean'
+                        ? params.tls
+                        : getTls(params.tls),
+                    connectTimeout: params.connectionTimeout ?? 10000,
+                },
+                host: params.host,
+                port: params.port ?? 3306,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { MariaDb, };

package/dist/db/adapters/mssql/MssqlDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class MssqlDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { MssqlDb, };

package/dist/db/adapters/mssql/MssqlDb.js

@@ -0,0 +1,40 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MssqlDb extends Db {
+    constructor(params) {
+        const tls = typeof params.tls === 'boolean'
+            ? undefined
+            : getTls(params.tls);
+        super({
+            options: {
+                dialect: 'mssql',
+                dialectOptions: {
+                    options: {
+                        encrypt: typeof params.tls === 'boolean'
+                            ? params.tls
+                            : Boolean(tls),
+                        cryptoCredentialsDetails: tls,
+                        trustServerCertificate: tls?.rejectUnauthorized === false,
+                        connectTimeout: params.connectionTimeout ?? 10000,
+                    },
+                },
+                host: params.host,
+                port: params.port ?? 1433,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { MssqlDb, };

package/dist/db/adapters/mysql/MysqlDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class MysqlDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { MysqlDb, };

package/dist/db/adapters/mysql/MysqlDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MysqlDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'mysql',
+                dialectOptions: {
+                    ssl: typeof params.tls === 'boolean'
+                        ? params.tls
+                        : getTls(params.tls),
+                    connectTimeout: params.connectionTimeout ?? 10000,
+                },
+                host: params.host,
+                port: params.port ?? 3306,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { MysqlDb, };

package/dist/db/adapters/postgres/PostgresDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class PostgresDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { PostgresDb, };

package/dist/db/adapters/postgres/PostgresDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class PostgresDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'postgres',
+                dialectOptions: {
+                    ssl: typeof params.tls === 'boolean'
+                        ? params.tls
+                        : getTls(params.tls),
+                    connectionTimeoutMillis: params.connectionTimeout ?? 10000,
+                },
+                host: params.host,
+                port: params.port ?? 5432,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { PostgresDb, };

package/dist/db/adapters/sqlite/SqliteDb.d.ts

@@ -0,0 +1,10 @@
+import { Db } from '../../Db.js';
+import type { Initializer } from '../../Initializer.js';
+declare class SqliteDb extends Db {
+    constructor(params: {
+        storage: string;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { SqliteDb, };

package/dist/db/adapters/sqlite/SqliteDb.js

@@ -0,0 +1,20 @@
+import SQLite from 'sqlite3';
+import { Db } from '../../Db.js';
+class SqliteDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'sqlite',
+                dialectOptions: {
+                    mode: SQLite.OPEN_FULLMUTEX
+                        | SQLite.OPEN_READWRITE
+                        | SQLite.OPEN_CREATE,
+                },
+                storage: params.storage,
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { SqliteDb, };

package/dist/db/adapters/sqlite/Storage.d.ts

@@ -0,0 +1,4 @@
+declare const Storage: {
+    MEMORY: string;
+};
+export { Storage, };

package/dist/db/adapters/sqlite/Storage.js

@@ -0,0 +1,4 @@
+const Storage = {
+    MEMORY: ':memory:',
+};
+export { Storage, };

package/dist/db/relationships.d.ts

@@ -0,0 +1,28 @@
+import type { Model, ModelStatic } from 'sequelize';
+declare const oneToOne: (fk: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}) => void;
+declare const oneToMany: (fk: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asMany: string;
+}) => void;
+declare const manyToMany: (fkA: string, fkB: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+    asMany: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asOne: string;
+    asMany: string;
+}, through: {
+    model: ModelStatic<Model>;
+    asMany: string;
+}) => void;
+export { manyToMany, oneToMany, oneToOne, };

package/dist/db/relationships.js

@@ -0,0 +1,15 @@
+const oneToOne = (fk, a, b) => {
+    a.model.hasOne(b.model, { foreignKey: fk, as: b.asOne });
+    b.model.belongsTo(a.model, { foreignKey: fk, as: a.asOne });
+};
+const oneToMany = (fk, a, b) => {
+    a.model.hasMany(b.model, { foreignKey: fk, as: b.asMany });
+    b.model.belongsTo(a.model, { foreignKey: fk, as: a.asOne });
+};
+const manyToMany = (fkA, fkB, a, b, through) => {
+    a.model.belongsToMany(b.model, { through: through.model, foreignKey: fkA, otherKey: fkB, as: b.asMany });
+    b.model.belongsToMany(a.model, { through: through.model, foreignKey: fkB, otherKey: fkA, as: a.asMany });
+    oneToMany(fkA, a, through);
+    oneToMany(fkB, b, through);
+};
+export { manyToMany, oneToMany, oneToOne, };

package/dist/env/Env.js

@@ -0,0 +1 @@
+export {};

package/{env → dist/env}/errors/FileReadError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class FileReadError extends BaseError {
     constructor(path: string, message: string);
 }

package/dist/env/errors/FileReadError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class FileReadError extends BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+export { FileReadError, };

package/{env → dist/env}/getEnv.d.ts

@@ -1,4 +1,4 @@
-import type { Env } from './Env';
+import type { Env } from './Env.js';
 declare const getEnv: (params?: {
     file?: {
         path: string;

package/dist/env/getEnv.js

@@ -0,0 +1,12 @@
+import { readFile } from './readFile.js';
+const getEnv = (params) => {
+    let file = {};
+    if (params?.file) {
+        file = readFile(params.file.path, params.file.required);
+    }
+    return {
+        ...file,
+        ...process.env,
+    };
+};
+export { getEnv, };

package/{env → dist/env}/readFile.d.ts

@@ -1,3 +1,3 @@
-import type { Env } from './Env';
+import type { Env } from './Env.js';
 declare const readFile: (path: string, required?: boolean) => Env;
 export { readFile, };

package/dist/env/readFile.js

@@ -0,0 +1,18 @@
+import dotenv from 'dotenv';
+import fs from 'fs-extra';
+import { FileReadError } from './errors/FileReadError.js';
+const readFile = (path, required = false) => {
+    try {
+        if (fs.existsSync(path)) {
+            return dotenv.parse(fs.readFileSync(path));
+        }
+    }
+    catch (error) {
+        throw new FileReadError(path, error.message);
+    }
+    if (required) {
+        throw new FileReadError(path, 'missing file');
+    }
+    return {};
+};
+export { readFile, };

package/{error → dist/error}/BaseError.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseError = void 0;
 class BaseError extends Error {
     constructor(message) {
         super(message);
@@ -9,4 +6,4 @@ class BaseError extends Error {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-exports.BaseError = BaseError;
+export { BaseError, };

package/dist/jwt/Algorithm.js

@@ -0,0 +1,7 @@
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["HS256"] = "HS256";
+    Algorithm["HS384"] = "HS384";
+    Algorithm["HS512"] = "HS512";
+})(Algorithm || (Algorithm = {}));
+export { Algorithm, };

package/{jwt → dist/jwt}/Jwt.d.ts

@@ -1,5 +1,5 @@
-import type { Algorithm } from './Algorithm';
-import type { Payload } from './Payload';
+import type { Algorithm } from './Algorithm.js';
+import type { Payload } from './Payload.js';
 declare class Jwt {
     private readonly algorithm;
     private readonly secret;

package/{jwt → dist/jwt}/Jwt.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Jwt = void 0;
-const jose_1 = require("jose");
-const validateSecretLength_1 = require("./validateSecretLength");
+import { jwtVerify, SignJWT } from 'jose';
+import { validateSecretLength } from './validateSecretLength.js';
 class Jwt {
     algorithm;
     secret;
     constructor(params) {
-        (0, validateSecretLength_1.validateSecretLength)(params.algorithm, params.secret);
+        validateSecretLength(params.algorithm, params.secret);
         this.algorithm = params.algorithm;
         this.secret = new TextEncoder().encode(params.secret);
     }
     async createToken(payload) {
-        return new jose_1.SignJWT(payload)
+        return new SignJWT(payload)
             .setProtectedHeader({
             typ: 'JWT',
             alg: this.algorithm,
@@ -21,7 +18,7 @@ class Jwt {
     }
     async verifyToken(token, timestamp) {
         try {
-            const { payload } = await (0, jose_1.jwtVerify)(token, this.secret, {
+            const { payload } = await jwtVerify(token, this.secret, {
                 typ: 'JWT',
                 currentDate: new Date(timestamp * 1000),
             });
@@ -32,4 +29,4 @@ class Jwt {
         }
     }
 }
-exports.Jwt = Jwt;
+export { Jwt, };

package/dist/jwt/Payload.js

@@ -0,0 +1 @@
+export {};

package/{jwt → dist/jwt}/errors/SecretLengthError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class SecretLengthError extends BaseError {
     constructor();
 }

package/dist/jwt/errors/SecretLengthError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class SecretLengthError extends BaseError {
+    constructor() {
+        super('invalid secret length');
+    }
+}
+export { SecretLengthError, };

package/{jwt → dist/jwt}/validateSecretLength.d.ts

@@ -1,3 +1,3 @@
-import { Algorithm } from './Algorithm';
+import { Algorithm } from './Algorithm.js';
 declare const validateSecretLength: (algorithm: Algorithm, secret: string) => void;
 export { validateSecretLength, };

package/dist/jwt/validateSecretLength.js

@@ -0,0 +1,13 @@
+import { Algorithm } from './Algorithm.js';
+import { SecretLengthError } from './errors/SecretLengthError.js';
+const minSecretLength = {
+    [Algorithm.HS256]: 32,
+    [Algorithm.HS384]: 48,
+    [Algorithm.HS512]: 64,
+};
+const validateSecretLength = (algorithm, secret) => {
+    if (Buffer.from(secret).length < minSecretLength[algorithm]) {
+        throw new SecretLengthError();
+    }
+};
+export { validateSecretLength, };

package/{logger → dist/logger}/Level.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Level = void 0;
 var Level;
 (function (Level) {
     Level["TRACE"] = "trace";
@@ -10,4 +7,5 @@ var Level;
     Level["ERROR"] = "error";
     Level["FATAL"] = "fatal";
     Level["OFF"] = "off";
-})(Level || (exports.Level = Level = {}));
+})(Level || (Level = {}));
+export { Level, };

package/dist/logger/Logger.js

@@ -0,0 +1,3 @@
+class Logger {
+}
+export { Logger, };

package/{logger → dist/logger}/Severity.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Severity = void 0;
 var Severity;
 (function (Severity) {
     Severity[Severity["TRACE"] = 10] = "TRACE";
@@ -9,4 +6,5 @@ var Severity;
     Severity[Severity["WARN"] = 40] = "WARN";
     Severity[Severity["ERROR"] = 50] = "ERROR";
     Severity[Severity["FATAL"] = 60] = "FATAL";
-})(Severity || (exports.Severity = Severity = {}));
+})(Severity || (Severity = {}));
+export { Severity, };

package/{logger → dist/logger}/adapters/file/FileLogger.d.ts

@@ -1,5 +1,5 @@
-import { Level } from '../../Level';
-import { Logger } from '../../Logger';
+import { Level } from '../../Level.js';
+import { Logger } from '../../Logger.js';
 declare class FileLogger extends Logger {
     private readonly logger;
     private readonly context;

package/{logger → dist/logger}/adapters/file/FileLogger.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileLogger = void 0;
-const pino_1 = __importDefault(require("pino"));
-const Level_1 = require("../../Level");
-const Logger_1 = require("../../Logger");
-const initFile_1 = require("./initFile");
-class FileLogger extends Logger_1.Logger {
+import { destination, pino } from 'pino';
+import { Level } from '../../Level.js';
+import { Logger } from '../../Logger.js';
+import { initFile } from './initFile.js';
+class FileLogger extends Logger {
     logger;
     context;
     constructor(params) {
         super();
-        (0, initFile_1.initFile)(params.path);
-        const stream = pino_1.default.destination(params.path);
-        this.logger = (0, pino_1.default)({
-            enabled: params.level !== Level_1.Level.OFF,
-            level: params.level ?? Level_1.Level.INFO,
+        initFile(params.path);
+        const stream = destination(params.path);
+        this.logger = pino({
+            enabled: params.level !== Level.OFF,
+            level: params.level ?? Level.INFO,
             messageKey: 'message',
             formatters: {
                 level(label, number) {
@@ -67,4 +61,4 @@ class FileLogger extends Logger_1.Logger {
         };
     }
 }
-exports.FileLogger = FileLogger;
+export { FileLogger, };

package/{logger → dist/logger}/adapters/file/errors/FileInitError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../../../error/BaseError';
+import { BaseError } from '../../../../error/BaseError.js';
 declare class FileInitError extends BaseError {
     constructor(path: string, message: string);
 }

package/dist/logger/adapters/file/errors/FileInitError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../../../error/BaseError.js';
+class FileInitError extends BaseError {
+    constructor(path, message) {
+        super(`failed initializing file "${path}": ${message}`);
+    }
+}
+export { FileInitError, };