apeframework 0.0.0-dev.2 → 0.0.0-dev.4

package/mailer/getIcalendar.ts

@@ -0,0 +1,39 @@
+import { ICalCalendar } from 'ical-generator'
+import type { Event } from './Event'
+import type { ICalCalendarMethod } from 'ical-generator'
+
+const getIcalendar = (event: Event): string => {
+  const calendar = new ICalCalendar({
+    method: event.method as unknown as ICalCalendarMethod,
+    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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAddressEmail = void 0;
+const isValidEmail_1 = require("utils/isValidEmail");
+const AddressEmailError_1 = require("./errors/AddressEmailError");
+const validateAddressEmail = (email) => {
+    if (!(0, isValidEmail_1.isValidEmail)(email)) {
+        throw new AddressEmailError_1.AddressEmailError(email);
+    }
+};
+exports.validateAddressEmail = validateAddressEmail;

package/mailer/validateAddressEmail.ts

@@ -0,0 +1,12 @@
+import { isValidEmail } from 'utils/isValidEmail'
+import { AddressEmailError } from './errors/AddressEmailError'
+
+const validateAddressEmail = (email: string): void => {
+  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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEventAttachmentUrl = void 0;
+const isValidUrl_1 = require("utils/isValidUrl");
+const EventAttachmentUrlError_1 = require("./errors/EventAttachmentUrlError");
+const validateEventAttachmentUrl = (url) => {
+    if (!(0, isValidUrl_1.isValidUrl)(url)) {
+        throw new EventAttachmentUrlError_1.EventAttachmentUrlError(url);
+    }
+};
+exports.validateEventAttachmentUrl = validateEventAttachmentUrl;

package/mailer/validateEventAttachmentUrl.ts

@@ -0,0 +1,12 @@
+import { isValidUrl } from 'utils/isValidUrl'
+import { EventAttachmentUrlError } from './errors/EventAttachmentUrlError'
+
+const validateEventAttachmentUrl = (url: string): void => {
+  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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEventGeolocation = void 0;
+const isValidGeolocation_1 = require("utils/isValidGeolocation");
+const EventGeolocationError_1 = require("./errors/EventGeolocationError");
+const validateEventGeolocation = (latitude, longitude) => {
+    if (!(0, isValidGeolocation_1.isValidGeolocation)(latitude, longitude)) {
+        throw new EventGeolocationError_1.EventGeolocationError(latitude, longitude);
+    }
+};
+exports.validateEventGeolocation = validateEventGeolocation;

package/mailer/validateEventGeolocation.ts

@@ -0,0 +1,15 @@
+import { isValidGeolocation } from 'utils/isValidGeolocation'
+import { EventGeolocationError } from './errors/EventGeolocationError'
+
+const validateEventGeolocation = (
+  latitude: number,
+  longitude: number,
+): void => {
+  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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEventUrl = void 0;
+const isValidUrl_1 = require("utils/isValidUrl");
+const EventUrlError_1 = require("./errors/EventUrlError");
+const validateEventUrl = (url) => {
+    if (!(0, isValidUrl_1.isValidUrl)(url)) {
+        throw new EventUrlError_1.EventUrlError(url);
+    }
+};
+exports.validateEventUrl = validateEventUrl;

package/mailer/validateEventUrl.ts

@@ -0,0 +1,12 @@
+import { isValidUrl } from 'utils/isValidUrl'
+import { EventUrlError } from './errors/EventUrlError'
+
+const validateEventUrl = (url: string): void => {
+  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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateListUrl = void 0;
+const isValidUrl_1 = require("utils/isValidUrl");
+const ListUrlError_1 = require("./errors/ListUrlError");
+const validateListUrl = (property, url) => {
+    if (!(0, isValidUrl_1.isValidUrl)(url)) {
+        throw new ListUrlError_1.ListUrlError(property, url);
+    }
+};
+exports.validateListUrl = validateListUrl;

package/mailer/validateListUrl.ts

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

package/package.json

@@ -1,53 +1,51 @@
 {
   "name": "apeframework",
-  "version": "0.0.0-dev.2",
+  "version": "0.0.0-dev.4",
   "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"
-  },
   "engines": {
-    "node": "^18"
+    "node": "^22"
   },
   "dependencies": {
-    "@fastify/cors": "^8.4",
-    "@fastify/response-validation": "^2.5",
-    "@fastify/swagger": "^8.10",
+    "@fastify/cors": "^9.0",
+    "@fastify/response-validation": "^2.6",
+    "@fastify/swagger": "^8.15",
     "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",
+    "bullmq": "^5.12",
+    "dotenv": "^16.4",
+    "fastify": "^4.28",
+    "fs-extra": "^11.2",
+    "ical-generator": "^8.0",
+    "ioredis": "^5.4",
+    "jose": "^5.8",
+    "knex": "^3.1",
+    "mysql2": "^3.11",
     "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",
+    "pg": "^8.12",
+    "pino": "^9.4",
+    "pino-pretty": "^11.2",
     "sqlite3": "^5.1",
     "yargs-parser": "^21.1"
+  },
+  "peerDependencies": {
+    "@types/node": "^22.5",
+    "ts-node": "^10.9",
+    "typescript": "^5.5"
   }
 }

package/parser/Parser.d.ts

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

package/parser/Parser.ts

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

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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class ParseError extends BaseError_1.BaseError {
+    constructor(type) {
+        super(`failed parsing ${type}`);
+    }
+}
+exports.ParseError = ParseError;

package/parser/errors/ParseError.ts

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

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.ts

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

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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnitParser = void 0;
+const ParseError_1 = require("../../errors/ParseError");
+const parseNumber_1 = require("../../parseNumber");
+const parseString_1 = require("../../parseString");
+const createUnitParser = (params) => {
+    return (input) => {
+        let string;
+        try {
+            string = (0, parseString_1.parseString)(input);
+        }
+        catch (error) {
+            throw new ParseError_1.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 = (0, parseNumber_1.parseNumber)(string.substring(0, string.length - (unit?.symbol.length ?? 0)));
+        }
+        catch (error) {
+            throw new ParseError_1.ParseError(params.type);
+        }
+        return number * (unit?.value ?? 1);
+    };
+};
+exports.createUnitParser = createUnitParser;

package/parser/factories/unit/createUnitParser.ts

@@ -0,0 +1,50 @@
+import { ParseError } from '../../errors/ParseError'
+import { parseNumber } from '../../parseNumber'
+import { parseString } from '../../parseString'
+import type { Unit } from './Unit'
+import type { Parser } from '../../Parser'
+
+const createUnitParser = (params: {
+  type: string,
+  units: Unit[],
+}): Parser<number> => {
+  return (input) => {
+    let string: string
+
+    try {
+      string = parseString(input)
+    } catch (error) {
+      throw new ParseError(params.type)
+    }
+
+    const units: Unit[] = []
+
+    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: 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,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const ParseError_1 = require("./errors/ParseError");
+const parseBoolean = (input) => {
+    if ([true, 1, BigInt(1), '1'].includes(input)) {
+        return true;
+    }
+    else if ([undefined, null, false, 0, BigInt(0), '', '0'].includes(input)) {
+        return false;
+    }
+    throw new ParseError_1.ParseError('boolean');
+};
+exports.parseBoolean = parseBoolean;

package/parser/parseBoolean.ts

@@ -0,0 +1,16 @@
+import { ParseError } from './errors/ParseError'
+import type { Parser } from './Parser'
+
+const parseBoolean: Parser<boolean> = (input) => {
+  if ([true, 1, BigInt(1), '1'].includes(input)) {
+    return true
+  } else if ([undefined, null, false, 0, BigInt(0), '', '0'].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,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBytes = void 0;
+const createUnitParser_1 = require("./factories/unit/createUnitParser");
+const parseBytes = (0, createUnitParser_1.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,
+        },
+    ],
+});
+exports.parseBytes = parseBytes;

package/parser/parseBytes.ts

@@ -0,0 +1,55 @@
+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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInteger = void 0;
+const ParseError_1 = require("./errors/ParseError");
+const parseNumber_1 = require("./parseNumber");
+const parseInteger = (input) => {
+    let number;
+    try {
+        number = (0, parseNumber_1.parseNumber)(input);
+    }
+    catch (error) {
+        throw new ParseError_1.ParseError('integer');
+    }
+    if (!Number.isSafeInteger(number)) {
+        throw new ParseError_1.ParseError('integer');
+    }
+    return number;
+};
+exports.parseInteger = parseInteger;

package/parser/parseInteger.ts

@@ -0,0 +1,23 @@
+import { ParseError } from './errors/ParseError'
+import { parseNumber } from './parseNumber'
+import type { Parser } from './Parser'
+
+const parseInteger: Parser<number> = (input) => {
+  let number: 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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMilliseconds = void 0;
+const createUnitParser_1 = require("./factories/unit/createUnitParser");
+const parseMilliseconds = (0, createUnitParser_1.createUnitParser)({
+    type: 'milliseconds',
+    units: [
+        {
+            symbol: 'ms',
+            value: 1,
+        },
+        {
+            symbol: 's',
+            value: 1000,
+        },
+        {
+            symbol: 'm',
+            value: 60000,
+        },
+        {
+            symbol: 'h',
+            value: 3600000,
+        },
+        {
+            symbol: 'd',
+            value: 86400000,
+        },
+    ],
+});
+exports.parseMilliseconds = parseMilliseconds;