apeframework 0.0.0-dev.2 → 0.0.0-dev.21

package/mailer/adapters/smtp/getAddress.js

@@ -0,0 +1,9 @@
+const getAddress = (address) => {
+    return address
+        ? {
+            address: address.email,
+            name: address.name ?? '',
+        }
+        : undefined;
+};
+export { getAddress, };

package/mailer/adapters/smtp/getAddresses.d.ts

@@ -0,0 +1,4 @@
+import type { Address } from '../../Address';
+import type { Address as NodemailerAddress } from 'nodemailer/lib/mailer';
+declare const getAddresses: (addresses?: Address[]) => NodemailerAddress[];
+export { getAddresses, };

package/mailer/adapters/smtp/getAddresses.js

@@ -0,0 +1,11 @@
+import { getAddress } from './getAddress';
+const getAddresses = (addresses) => {
+    return addresses
+        ? addresses
+            .map(getAddress)
+            .filter((address) => {
+            return address !== undefined;
+        })
+        : [];
+};
+export { getAddresses, };

package/mailer/adapters/smtp/getAttachments.d.ts

@@ -0,0 +1,4 @@
+import type { Attachment } from '../../Attachment';
+import type { Attachment as NodemailerAttachment } from 'nodemailer/lib/mailer';
+declare const getAttachments: (attachments?: Attachment[]) => NodemailerAttachment[];
+export { getAttachments, };

package/mailer/adapters/smtp/getAttachments.js

@@ -0,0 +1,14 @@
+const getAttachments = (attachments) => {
+    return attachments
+        ? attachments
+            .map((attachment) => {
+            return {
+                filename: attachment.fileName,
+                cid: attachment.fileName,
+                contentType: attachment.contentType,
+                content: attachment.content,
+            };
+        })
+        : [];
+};
+export { getAttachments, };

package/mailer/errors/AddressEmailError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class AddressEmailError extends BaseError {
+    constructor(email: string);
+}
+export { AddressEmailError, };

package/mailer/errors/AddressEmailError.js

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

package/mailer/errors/EventAttachmentUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class EventAttachmentUrlError extends BaseError {
+    constructor(url: string);
+}
+export { EventAttachmentUrlError, };

package/mailer/errors/EventAttachmentUrlError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class EventAttachmentUrlError extends BaseError {
+    constructor(url) {
+        super(`invalid event attachment url "${url}"`);
+    }
+}
+export { EventAttachmentUrlError, };

package/mailer/errors/EventGeolocationError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class EventGeolocationError extends BaseError {
+    constructor(latitude: number, longitude: number);
+}
+export { EventGeolocationError, };

package/mailer/errors/EventGeolocationError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class EventGeolocationError extends BaseError {
+    constructor(latitude, longitude) {
+        super(`invalid event geolocation "${latitude}, ${longitude}"`);
+    }
+}
+export { EventGeolocationError, };

package/mailer/errors/EventUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class EventUrlError extends BaseError {
+    constructor(url: string);
+}
+export { EventUrlError, };

package/mailer/errors/EventUrlError.js

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

package/mailer/errors/ListUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class ListUrlError extends BaseError {
+    constructor(property: string, url: string);
+}
+export { ListUrlError, };

package/mailer/errors/ListUrlError.js

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

package/mailer/getIcalendar.d.ts

@@ -0,0 +1,3 @@
+import type { Event } from './Event';
+declare const getIcalendar: (event: Event) => string;
+export { getIcalendar, };

package/mailer/getIcalendar.js

@@ -0,0 +1,32 @@
+import { ICalCalendar } from 'ical-generator';
+const getIcalendar = (event) => {
+    const calendar = new ICalCalendar({
+        method: event.method,
+        events: [
+            {
+                id: event.id,
+                start: event.start,
+                end: event.end,
+                allDay: event.allDay,
+                summary: event.name,
+                description: event.description,
+                url: event.url,
+                location: event.location
+                    ? {
+                        title: event.location.name,
+                        address: event.location.address,
+                        geo: event.location.geo
+                            ? {
+                                lat: event.location.geo.latitude,
+                                lon: event.location.geo.longitude,
+                            }
+                            : undefined,
+                    }
+                    : undefined,
+                attachments: event.attachments,
+            },
+        ],
+    });
+    return calendar.toString();
+};
+export { getIcalendar, };

package/mailer/validateAddressEmail.d.ts

@@ -0,0 +1,2 @@
+declare const validateAddressEmail: (email: string) => void;
+export { validateAddressEmail, };

package/mailer/validateAddressEmail.js

@@ -0,0 +1,8 @@
+import { isValidEmail } from 'utils/isValidEmail';
+import { AddressEmailError } from './errors/AddressEmailError';
+const validateAddressEmail = (email) => {
+    if (!isValidEmail(email)) {
+        throw new AddressEmailError(email);
+    }
+};
+export { validateAddressEmail, };

package/mailer/validateEventAttachmentUrl.d.ts

@@ -0,0 +1,2 @@
+declare const validateEventAttachmentUrl: (url: string) => void;
+export { validateEventAttachmentUrl, };

package/mailer/validateEventAttachmentUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from 'utils/isValidUrl';
+import { EventAttachmentUrlError } from './errors/EventAttachmentUrlError';
+const validateEventAttachmentUrl = (url) => {
+    if (!isValidUrl(url)) {
+        throw new EventAttachmentUrlError(url);
+    }
+};
+export { validateEventAttachmentUrl, };

package/mailer/validateEventGeolocation.d.ts

@@ -0,0 +1,2 @@
+declare const validateEventGeolocation: (latitude: number, longitude: number) => void;
+export { validateEventGeolocation, };

package/mailer/validateEventGeolocation.js

@@ -0,0 +1,8 @@
+import { isValidGeolocation } from 'utils/isValidGeolocation';
+import { EventGeolocationError } from './errors/EventGeolocationError';
+const validateEventGeolocation = (latitude, longitude) => {
+    if (!isValidGeolocation(latitude, longitude)) {
+        throw new EventGeolocationError(latitude, longitude);
+    }
+};
+export { validateEventGeolocation, };

package/mailer/validateEventUrl.d.ts

@@ -0,0 +1,2 @@
+declare const validateEventUrl: (url: string) => void;
+export { validateEventUrl, };

package/mailer/validateEventUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from 'utils/isValidUrl';
+import { EventUrlError } from './errors/EventUrlError';
+const validateEventUrl = (url) => {
+    if (!isValidUrl(url)) {
+        throw new EventUrlError(url);
+    }
+};
+export { validateEventUrl, };

package/mailer/validateListUrl.d.ts

@@ -0,0 +1,2 @@
+declare const validateListUrl: (property: string, url: string) => void;
+export { validateListUrl, };

package/mailer/validateListUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from 'utils/isValidUrl';
+import { ListUrlError } from './errors/ListUrlError';
+const validateListUrl = (property, url) => {
+    if (!isValidUrl(url)) {
+        throw new ListUrlError(property, url);
+    }
+};
+export { validateListUrl, };

package/package.json

@@ -1,53 +1,52 @@
 {
   "name": "apeframework",
-  "version": "0.0.0-dev.2",
+  "version": "0.0.0-dev.21",
   "license": "MIT",
   "author": "Matthieu Symoens",
-  "description": "Node.js API framework.",
+  "description": "Node.js app framework",
   "keywords": [
     "ape",
-    "framework"
+    "framework",
+    "nodejs"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ApeCommerce/ape-framework.git"
+    "url": "git+https://github.com/ApeFramework/apeframework.git"
   },
   "publishConfig": {
     "access": "public"
   },
-  "main": "index.js",
-  "types": "index.d.ts",
-  "bin": {
-    "ape-cli": "bin/ape-cli.js",
-    "ape-cli-ts": "bin/ape-cli-ts.js"
-  },
+  "type": "module",
   "engines": {
-    "node": "^18"
+    "node": "^22"
   },
   "dependencies": {
-    "@fastify/cors": "^8.4",
-    "@fastify/response-validation": "^2.5",
-    "@fastify/swagger": "^8.10",
-    "bcrypt": "^5.1",
-    "bullmq": "^4.11",
-    "bytes": "^3.1",
-    "dotenv": "^16.3",
-    "fastify": "^4.23",
-    "fs-extra": "^11.1",
-    "i18next": "^23.5",
-    "ioredis": "^5.3",
-    "jose": "^4.14",
-    "knex": "^2.5",
-    "mailgen": "^2.0",
-    "mysql2": "^3.6",
+    "@fastify/compress": "^8.0",
+    "@fastify/cors": "^10.0",
+    "@fastify/response-validation": "^3.0",
+    "@fastify/swagger": "^9.4",
+    "@types/bcryptjs": "^2.4",
+    "@types/fs-extra": "^11.0",
+    "@types/nodemailer": "^6.4",
+    "@types/yargs-parser": "^21.0",
+    "ajv": "^8.17",
+    "bcryptjs": "^2.4",
+    "bullmq": "^5.34",
+    "dotenv": "^16.4",
+    "fast-uri": "^3.0",
+    "fastify": "^5.2",
+    "fs-extra": "^11.2",
+    "ical-generator": "^8.0",
+    "ioredis": "^5.4",
+    "jose": "^5.9",
     "nodemailer": "^6.9",
     "openapi-types": "^12.1",
-    "parse-duration": "^1.1",
-    "pg": "^8.11",
-    "pino": "^8.15",
-    "pino-pretty": "^10.2",
-    "sonic-boom": "^3.3",
-    "sqlite3": "^5.1",
+    "pino": "^9.5",
+    "pino-pretty": "^13.0",
     "yargs-parser": "^21.1"
+  },
+  "peerDependencies": {
+    "@types/node": "^22.10",
+    "typescript": "^5.7"
   }
 }

package/parser/Parser.d.ts

@@ -0,0 +1,2 @@
+type Parser<Type> = (input: any) => Type;
+export { type Parser, };

package/parser/Parser.js

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

package/parser/errors/ParseError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class ParseError extends BaseError {
+    constructor(type: string);
+}
+export { ParseError, };

package/parser/errors/ParseError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class ParseError extends BaseError {
+    constructor(type) {
+        super(`failed parsing ${type}`);
+    }
+}
+export { ParseError, };

package/parser/factories/enum/createEnumParser.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from '../../Parser';
+declare const createEnumParser: <Type extends Record<string, string | number>>(params: {
+    type: string;
+    enum: Type;
+}) => Parser<Type[keyof Type]>;
+export { createEnumParser, };

package/parser/factories/enum/createEnumParser.js

@@ -0,0 +1,10 @@
+import { ParseError } from '../../errors/ParseError';
+const createEnumParser = (params) => {
+    return (input) => {
+        if (!Object.values(params.enum).includes(input)) {
+            throw new ParseError(params.type);
+        }
+        return input;
+    };
+};
+export { createEnumParser, };

package/parser/factories/unit/Unit.d.ts

@@ -0,0 +1,5 @@
+interface Unit {
+    symbol: string;
+    value: number;
+}
+export { type Unit, };

package/parser/factories/unit/Unit.js

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

package/parser/factories/unit/createUnitParser.d.ts

@@ -0,0 +1,7 @@
+import type { Unit } from './Unit';
+import type { Parser } from '../../Parser';
+declare const createUnitParser: (params: {
+    type: string;
+    units: Unit[];
+}) => Parser<number>;
+export { createUnitParser, };

package/parser/factories/unit/createUnitParser.js

@@ -0,0 +1,33 @@
+import { ParseError } from '../../errors/ParseError';
+import { parseNumber } from '../../parseNumber';
+import { parseString } from '../../parseString';
+const createUnitParser = (params) => {
+    return (input) => {
+        let string;
+        try {
+            string = parseString(input);
+        }
+        catch (error) {
+            throw new ParseError(params.type);
+        }
+        const units = [];
+        params.units.forEach((u) => {
+            units.push(u, { ...u, symbol: ` ${u.symbol}` });
+        });
+        units.sort((a, b) => {
+            return b.symbol.length - a.symbol.length;
+        });
+        const unit = units.find((u) => {
+            return string.toUpperCase().endsWith(u.symbol.toUpperCase());
+        });
+        let number;
+        try {
+            number = parseNumber(string.substring(0, string.length - (unit?.symbol.length ?? 0)));
+        }
+        catch (error) {
+            throw new ParseError(params.type);
+        }
+        return number * (unit?.value ?? 1);
+    };
+};
+export { createUnitParser, };

package/parser/parseBoolean.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseBoolean: Parser<boolean>;
+export { parseBoolean, };

package/parser/parseBoolean.js

@@ -0,0 +1,28 @@
+import { ParseError } from './errors/ParseError';
+const parseBoolean = (input) => {
+    if ([
+        true,
+        1,
+        BigInt(1),
+        '1',
+        'TRUE',
+        'true',
+    ].includes(input)) {
+        return true;
+    }
+    else if ([
+        undefined,
+        null,
+        false,
+        0,
+        BigInt(0),
+        '',
+        '0',
+        'FALSE',
+        'false',
+    ].includes(input)) {
+        return false;
+    }
+    throw new ParseError('boolean');
+};
+export { parseBoolean, };

package/parser/parseBytes.d.ts

@@ -0,0 +1,2 @@
+declare const parseBytes: import("./Parser").Parser<number>;
+export { parseBytes, };

package/parser/parseBytes.js

@@ -0,0 +1,51 @@
+import { createUnitParser } from './factories/unit/createUnitParser';
+const parseBytes = createUnitParser({
+    type: 'bytes',
+    units: [
+        {
+            symbol: 'B',
+            value: 1,
+        },
+        {
+            symbol: 'kB',
+            value: 1000,
+        },
+        {
+            symbol: 'MB',
+            value: 1000000,
+        },
+        {
+            symbol: 'GB',
+            value: 1000000000,
+        },
+        {
+            symbol: 'TB',
+            value: 1000000000000,
+        },
+        {
+            symbol: 'PB',
+            value: 1000000000000000,
+        },
+        {
+            symbol: 'KiB',
+            value: 1024,
+        },
+        {
+            symbol: 'MiB',
+            value: 131072,
+        },
+        {
+            symbol: 'GiB',
+            value: 134200000,
+        },
+        {
+            symbol: 'TiB',
+            value: 137400000000,
+        },
+        {
+            symbol: 'PiB',
+            value: 140700000000000,
+        },
+    ],
+});
+export { parseBytes, };

package/parser/parseInteger.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseInteger: Parser<number>;
+export { parseInteger, };

package/parser/parseInteger.js

@@ -0,0 +1,16 @@
+import { ParseError } from './errors/ParseError';
+import { parseNumber } from './parseNumber';
+const parseInteger = (input) => {
+    let number;
+    try {
+        number = parseNumber(input);
+    }
+    catch (error) {
+        throw new ParseError('integer');
+    }
+    if (!Number.isSafeInteger(number)) {
+        throw new ParseError('integer');
+    }
+    return number;
+};
+export { parseInteger, };

package/parser/parseMilliseconds.d.ts

@@ -0,0 +1,2 @@
+declare const parseMilliseconds: import("./Parser").Parser<number>;
+export { parseMilliseconds, };

package/parser/parseMilliseconds.js

@@ -0,0 +1,27 @@
+import { createUnitParser } from './factories/unit/createUnitParser';
+const parseMilliseconds = createUnitParser({
+    type: 'milliseconds',
+    units: [
+        {
+            symbol: 'ms',
+            value: 1,
+        },
+        {
+            symbol: 's',
+            value: 1000,
+        },
+        {
+            symbol: 'm',
+            value: 60000,
+        },
+        {
+            symbol: 'h',
+            value: 3600000,
+        },
+        {
+            symbol: 'd',
+            value: 86400000,
+        },
+    ],
+});
+export { parseMilliseconds, };

package/parser/parseNumber.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseNumber: Parser<number>;
+export { parseNumber, };

package/parser/parseNumber.js

@@ -0,0 +1,15 @@
+import { ParseError } from './errors/ParseError';
+const parseNumber = (input) => {
+    if ([undefined, null].includes(input)) {
+        return 0;
+    }
+    else if (['object', 'function', 'symbol'].includes(typeof input)) {
+        throw new ParseError('number');
+    }
+    const number = Number(input);
+    if (!Number.isFinite(number)) {
+        throw new ParseError('number');
+    }
+    return number;
+};
+export { parseNumber, };

package/parser/parseString.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseString: Parser<string>;
+export { parseString, };

package/parser/parseString.js

@@ -0,0 +1,11 @@
+import { ParseError } from './errors/ParseError';
+const parseString = (input) => {
+    if ([undefined, null].includes(input)) {
+        return '';
+    }
+    else if (['object', 'function', 'symbol'].includes(typeof input)) {
+        throw new ParseError('string');
+    }
+    return String(input);
+};
+export { parseString, };

package/pwd/Pwd.d.ts

@@ -0,0 +1,9 @@
+declare class Pwd {
+    private readonly hashRounds;
+    constructor(params: {
+        hashRounds: number;
+    });
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+}
+export { Pwd, };

package/pwd/Pwd.js

@@ -0,0 +1,16 @@
+import bcrypt from 'bcryptjs';
+import { validateHashRounds } from './validateHashRounds';
+class Pwd {
+    hashRounds;
+    constructor(params) {
+        validateHashRounds(params.hashRounds);
+        this.hashRounds = params.hashRounds;
+    }
+    async hashPassword(password) {
+        return bcrypt.hashSync(password, this.hashRounds);
+    }
+    async verifyPassword(password, hash) {
+        return bcrypt.compareSync(password, hash);
+    }
+}
+export { Pwd, };

package/pwd/errors/HashRoundsError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class HashRoundsError extends BaseError {
+    constructor(hashRounds: number);
+}
+export { HashRoundsError, };