apeframework 0.0.0-dev.9 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Matthieu Symoens
+Copyright (c) 2025 Matthieu Symoens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,10 +4,56 @@
 
 NPM package: [apeframework](https://www.npmjs.com/package/apeframework).
 
-GitHub repository: [ApeFramework/apeframework](https://github.com/ApeFramework/apeframework).
+GitHub repository: [MattSyms/apeframework](https://github.com/MattSyms/apeframework).
 
 ## Installation
 
 ```
 yarn add apeframework
 ```
+
+## Development
+
+Install dependencies:
+
+```
+yarn
+```
+
+Update dependencies:
+
+```
+yarn update
+```
+
+Compile:
+
+```
+yarn compile
+```
+
+Lint:
+
+```
+yarn lint
+```
+
+## Release:
+
+Tag stable release:
+
+```
+git tag v<major>.<minor>.<patch>
+```
+
+Tag dev release:
+
+```
+git tag v0.0.0-dev.<number>
+```
+
+Push tags:
+
+```
+git push --tags
+```

package/{cipher → dist/cipher}/Algorithm.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Algorithm = void 0;
 var Algorithm;
 (function (Algorithm) {
     Algorithm["AES128"] = "aes-128-cbc";
     Algorithm["AES192"] = "aes-192-cbc";
     Algorithm["AES256"] = "aes-256-cbc";
-})(Algorithm || (exports.Algorithm = Algorithm = {}));
+})(Algorithm || (Algorithm = {}));
+export { Algorithm, };

package/{cipher → dist/cipher}/Cipher.d.ts

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

package/dist/cipher/Cipher.js

@@ -0,0 +1,32 @@
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { DecryptError } from './errors/DecryptError.js';
+import { validateSecretLength } from './validateSecretLength.js';
+class Cipher {
+    algorithm;
+    secret;
+    constructor(params) {
+        validateSecretLength(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = Buffer.from(params.secret, 'utf8');
+    }
+    encrypt(string) {
+        const iv = randomBytes(16);
+        const cipher = createCipheriv(this.algorithm, this.secret, iv);
+        return iv.toString('hex')
+            + cipher.update(string, 'utf8', 'hex')
+            + cipher.final('hex');
+    }
+    decrypt(string) {
+        const buffer = Buffer.from(string, 'hex');
+        const iv = buffer.subarray(0, 16);
+        const decipher = createDecipheriv(this.algorithm, this.secret, iv);
+        try {
+            return decipher.update(buffer.subarray(16), undefined, 'utf8')
+                + decipher.final('utf8');
+        }
+        catch (error) {
+            throw new DecryptError(error.message);
+        }
+    }
+}
+export { Cipher, };

package/{cipher → dist/cipher}/errors/DecryptError.d.ts

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

package/dist/cipher/errors/DecryptError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class DecryptError extends BaseError {
+    constructor(message) {
+        super(`failed decrypting string: ${message}`);
+    }
+}
+export { DecryptError, };

package/{cipher → dist/cipher}/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/cipher/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/{cipher → dist/cipher}/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/cipher/validateSecretLength.js

@@ -0,0 +1,13 @@
+import { Algorithm } from './Algorithm.js';
+import { SecretLengthError } from './errors/SecretLengthError.js';
+const secretLength = {
+    [Algorithm.AES128]: 16,
+    [Algorithm.AES192]: 24,
+    [Algorithm.AES256]: 32,
+};
+const validateSecretLength = (algorithm, secret) => {
+    if (Buffer.from(secret).length !== secretLength[algorithm]) {
+        throw new SecretLengthError();
+    }
+};
+export { validateSecretLength, };

package/{cli → dist/cli}/Args.d.ts

@@ -1,5 +1,5 @@
 interface Args {
     positional: string[];
-    optional: Record<string, boolean | string>;
+    optional: Record<string, boolean | string | undefined>;
 }
 export { type Args, };

package/dist/cli/Args.js

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

package/{cli → dist/cli}/Command.d.ts

@@ -1,3 +1,3 @@
-import type { Args } from './Args';
+import type { Args } from './Args.js';
 type Command = (args: Args) => Promise<void>;
 export { type Command, };

package/dist/cli/Command.js

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

package/{cli → dist/cli}/getArgs.d.ts

@@ -1,3 +1,3 @@
-import type { Args } from './Args';
+import type { Args } from './Args.js';
 declare const getArgs: () => Args;
 export { getArgs, };

package/dist/cli/getArgs.js

@@ -0,0 +1,5 @@
+import { parseArgs } from './parseArgs.js';
+const getArgs = () => {
+    return parseArgs(process.argv.slice(2));
+};
+export { getArgs, };

package/{cli → dist/cli}/parseArgs.d.ts

@@ -1,3 +1,3 @@
-import type { Args } from './Args';
+import type { Args } from './Args.js';
 declare const parseArgs: (args: string[]) => Args;
 export { parseArgs, };

package/{cli → dist/cli}/parseArgs.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = void 0;
-const yargs_parser_1 = __importDefault(require("yargs-parser"));
+import yargsParser from 'yargs-parser';
 const parseArgs = (args) => {
-    const parsed = (0, yargs_parser_1.default)(args, {
+    const parsed = yargsParser(args, {
         configuration: {
             'boolean-negation': false,
             'camel-case-expansion': true,
@@ -28,4 +22,4 @@ const parseArgs = (args) => {
         optional,
     };
 };
-exports.parseArgs = parseArgs;
+export { parseArgs, };

package/dist/cli/utils/exit.js

@@ -0,0 +1,4 @@
+const exit = (code) => {
+    process.exit(code);
+};
+export { exit, };

package/dist/cli/utils/formatList.js

@@ -0,0 +1,7 @@
+import { EOL } from 'node:os';
+const formatList = (list) => {
+    return list
+        .map((item) => { return `  ${item}`; })
+        .join(EOL);
+};
+export { formatList, };

package/{cli → dist/cli}/utils/formatTable.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatTable = void 0;
-const os_1 = require("os");
+import { EOL } from 'node:os';
 const formatTable = (table) => {
     const colLength = [];
     table.forEach((row) => {
@@ -17,6 +14,6 @@ const formatTable = (table) => {
             .map((col, i) => { return col.padEnd(colLength[i], ' '); })
             .join('  ');
     })
-        .join(os_1.EOL);
+        .join(EOL);
 };
-exports.formatTable = formatTable;
+export { formatTable, };

package/dist/cli/utils/formatText.js

@@ -0,0 +1,5 @@
+import { EOL } from 'node:os';
+const formatText = (text) => {
+    return text.join(EOL);
+};
+export { formatText, };

package/dist/cli/utils/print.js

@@ -0,0 +1,4 @@
+const print = (s) => {
+    process.stdout.write(s);
+};
+export { print, };

package/dist/cli/utils/printLn.js

@@ -0,0 +1,5 @@
+import { EOL } from 'node:os';
+const printLn = (s) => {
+    process.stdout.write(`${s}${EOL}`);
+};
+export { printLn, };

package/dist/config/Config.d.ts

@@ -0,0 +1,2 @@
+type Config = Record<string, any>;
+export { type Config, };

package/dist/config/Config.js

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

package/{config → dist/config}/Properties.d.ts

@@ -1,4 +1,4 @@
-import type { Parser } from '../parser/Parser';
+import type { Parser } from '../parser/Parser.js';
 type Properties<Type> = {
     [Property in keyof Type]: {
         parser: Parser<Type[Property]>;

package/dist/config/Properties.js

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

package/{config → dist/config}/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/config/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/{config → dist/config}/errors/PropertyNameError.d.ts

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

package/dist/config/errors/PropertyNameError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class PropertyNameError extends BaseError {
+    constructor(name) {
+        super(`invalid property name "${name}"`);
+    }
+}
+export { PropertyNameError, };

package/{config → dist/config}/errors/PropertyParseError.d.ts

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

package/dist/config/errors/PropertyParseError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class PropertyParseError extends BaseError {
+    constructor(name, source, message) {
+        super(`failed parsing property "${name}" from ${source}: ${message}`);
+    }
+}
+export { PropertyParseError, };

package/{config → dist/config}/getConfig.d.ts

@@ -1,7 +1,7 @@
-import type { Config } from './Config';
-import type { Properties } from './Properties';
-import type { Args } from '../cli/Args';
-import type { Env } from '../env/Env';
+import type { Config } from './Config.js';
+import type { Properties } from './Properties.js';
+import type { Args } from '../cli/Args.js';
+import type { Env } from '../env/Env.js';
 declare const getConfig: <Type extends Config>(params: {
     properties: Properties<Type>;
     file?: {

package/dist/config/getConfig.js

@@ -0,0 +1,18 @@
+import { getPropertyEnvVar } from './getPropertyEnvVar.js';
+import { parseProperty } from './parseProperty.js';
+import { readFile } from './readFile.js';
+import { validatePropertyName } from './validatePropertyName.js';
+const getConfig = (params) => {
+    const file = params.file
+        ? readFile(params.file.path, params.file.required)
+        : {};
+    const env = params.env ?? {};
+    const args = params.args ?? { positional: [], optional: {} };
+    const config = {};
+    for (const name in params.properties) {
+        validatePropertyName(name);
+        config[name] = parseProperty(name, params.properties[name].parser, params.properties[name].default, file[name], env[getPropertyEnvVar(name)], args.optional[name]);
+    }
+    return config;
+};
+export { getConfig, };

package/{config → dist/config}/getPropertyEnvVar.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropertyEnvVar = void 0;
 const capitalLetterRegex = /[A-Z]/gu;
 const capitalLetterReplacer = (letter) => {
     return `_${letter}`;
@@ -10,4 +7,4 @@ const getPropertyEnvVar = (name) => {
         .replace(capitalLetterRegex, capitalLetterReplacer)
         .toUpperCase();
 };
-exports.getPropertyEnvVar = getPropertyEnvVar;
+export { getPropertyEnvVar, };

package/{config → dist/config}/parseProperty.d.ts

@@ -1,3 +1,3 @@
-import type { Parser } from '../parser/Parser';
+import type { Parser } from '../parser/Parser.js';
 declare const parseProperty: <Type>(name: string, parser: Parser<Type>, defaultValue: any, fileValue: any, envValue: any, argsValue: any) => Type;
 export { parseProperty, };

package/{config → dist/config}/parseProperty.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseProperty = void 0;
-const PropertyParseError_1 = require("./errors/PropertyParseError");
+import { PropertyParseError } from './errors/PropertyParseError.js';
 const parseProperty = (name, parser, defaultValue, fileValue, envValue, argsValue) => {
     const sources = [
         {
@@ -31,7 +28,7 @@ const parseProperty = (name, parser, defaultValue, fileValue, envValue, argsValu
         return parser(source.value);
     }
     catch (error) {
-        throw new PropertyParseError_1.PropertyParseError(name, source.name, error.message);
+        throw new PropertyParseError(name, source.name, error.message);
     }
 };
-exports.parseProperty = parseProperty;
+export { parseProperty, };

package/dist/config/readFile.js

@@ -0,0 +1,25 @@
+import fs from 'fs-extra';
+import { FileReadError } from './errors/FileReadError.js';
+const readFile = (path, required = false) => {
+    let json = {};
+    let fileExists;
+    try {
+        fileExists = fs.existsSync(path);
+        if (fileExists) {
+            json = fs.readJsonSync(path);
+        }
+    }
+    catch (error) {
+        throw new FileReadError(path, error.message);
+    }
+    if (required && !fileExists) {
+        throw new FileReadError(path, 'missing file');
+    }
+    if (typeof json !== 'object'
+        || Array.isArray(json)
+        || json === null) {
+        throw new FileReadError(path, 'invalid content');
+    }
+    return json;
+};
+export { readFile, };

package/dist/config/validatePropertyName.js

@@ -0,0 +1,8 @@
+import { PropertyNameError } from './errors/PropertyNameError.js';
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u;
+const validatePropertyName = (name) => {
+    if (!propertyNameRegex.test(name)) {
+        throw new PropertyNameError(name);
+    }
+};
+export { validatePropertyName, };

package/dist/db/DataType.d.ts

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

package/dist/db/DataType.js

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

package/dist/db/Db.d.ts

@@ -0,0 +1,3 @@
+import type { Sequelize } from 'sequelize';
+type Db = Sequelize;
+export type { Db, };

package/dist/db/Db.js

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

package/dist/db/IndexType.d.ts

@@ -0,0 +1,6 @@
+declare enum IndexType {
+    FULLTEXT = "FULLTEXT",
+    SPATIAL = "SPATIAL",
+    UNIQUE = "UNIQUE"
+}
+export { IndexType, };

package/dist/db/IndexType.js

@@ -0,0 +1,7 @@
+var IndexType;
+(function (IndexType) {
+    IndexType["FULLTEXT"] = "FULLTEXT";
+    IndexType["SPATIAL"] = "SPATIAL";
+    IndexType["UNIQUE"] = "UNIQUE";
+})(IndexType || (IndexType = {}));
+export { IndexType, };

package/dist/db/Initializer.d.ts

@@ -0,0 +1,3 @@
+import type { Sequelize } from 'sequelize';
+type Initializer = (db: Sequelize) => void;
+export { type Initializer, };

package/dist/db/Initializer.js

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

package/dist/db/Migration.d.ts

@@ -0,0 +1,6 @@
+import type { QueryInterface } from 'sequelize';
+interface Migration {
+    up: (db: QueryInterface) => Promise<void>;
+    down: (db: QueryInterface) => Promise<void>;
+}
+export { type Migration, };

package/dist/db/Migration.js

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

package/dist/db/MigrationStatus.d.ts

@@ -0,0 +1,5 @@
+declare enum MigrationStatus {
+    APPLIED = "APPLIED",
+    PENDING = "PENDING"
+}
+export { MigrationStatus, };

package/dist/db/MigrationStatus.js

@@ -0,0 +1,6 @@
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["APPLIED"] = "APPLIED";
+    MigrationStatus["PENDING"] = "PENDING";
+})(MigrationStatus || (MigrationStatus = {}));
+export { MigrationStatus, };

package/dist/db/Migrator.d.ts

@@ -0,0 +1,20 @@
+import { MigrationStatus } from './MigrationStatus.js';
+import type { Db } from './Db.js';
+declare class Migrator {
+    private readonly umzug;
+    constructor(params: {
+        db: Db;
+        modelName: string;
+        directory: string;
+        extension: string;
+        onApply?: (name: string) => void;
+        onRevert?: (name: string) => void;
+    });
+    list(status?: MigrationStatus): Promise<{
+        name: string;
+        status: MigrationStatus;
+    }[]>;
+    apply(count?: number): Promise<string[]>;
+    revert(count?: number): Promise<string[]>;
+}
+export { Migrator, };

package/dist/db/Migrator.js

@@ -0,0 +1,69 @@
+import { basename, extname } from 'node:path';
+import { SequelizeStorage, Umzug } from 'umzug';
+import { MigrationStatus } from './MigrationStatus.js';
+class Migrator {
+    umzug;
+    constructor(params) {
+        const glob = `${params.directory}/*.${params.extension}`;
+        const resolve = ({ name: filename, context }) => {
+            const name = basename(filename, extname(filename));
+            const up = async ({ path: file }) => {
+                const module = await import(String(file));
+                await module.migration.up(context);
+            };
+            const down = async ({ path: file }) => {
+                const module = await import(String(file));
+                await module.migration.down(context);
+            };
+            return { name, up, down };
+        };
+        this.umzug = new Umzug({
+            storage: new SequelizeStorage({
+                sequelize: params.db,
+                modelName: params.modelName,
+            }),
+            migrations: { glob, resolve },
+            context: params.db.getQueryInterface(),
+            logger: undefined,
+        });
+        this.umzug.on('migrating', (e) => {
+            params.onApply?.(e.name);
+        });
+        this.umzug.on('reverting', (e) => {
+            params.onRevert?.(e.name);
+        });
+    }
+    async list(status) {
+        return [
+            ...status === MigrationStatus.PENDING
+                ? []
+                : (await this.umzug.executed()).map((migration) => {
+                    return {
+                        name: migration.name,
+                        status: MigrationStatus.APPLIED,
+                    };
+                }),
+            ...status === MigrationStatus.APPLIED
+                ? []
+                : (await this.umzug.pending()).map((migration) => {
+                    return {
+                        name: migration.name,
+                        status: MigrationStatus.PENDING,
+                    };
+                }),
+        ];
+    }
+    async apply(count) {
+        return (await this.umzug.up(count ? { step: count } : undefined))
+            .map((migration) => {
+            return migration.name;
+        });
+    }
+    async revert(count) {
+        return (await this.umzug.down(count ? { step: count } : { to: 0 }))
+            .map((migration) => {
+            return migration.name;
+        });
+    }
+}
+export { Migrator, };

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 {};