apeframework 0.0.0-dev.1

package/mq/mq.ts

@@ -0,0 +1,18 @@
+import type { Job, Queue } from './queue'
+
+export interface Mq {
+  getQueues: () => Promise<Queue[]>,
+  getQueue: (queueId: string) => Promise<Queue | undefined>,
+  createSender: (queue: Queue) => Sender,
+  createWorker: (queue: Queue) => Worker,
+}
+
+export interface Sender {
+  send: <Data>(job: Job, data: Data) => Promise<void>,
+  close: () => Promise<void>,
+}
+
+export interface Worker {
+  start: () => void,
+  close: () => Promise<void>,
+}

package/mq/queue.d.ts

@@ -0,0 +1,9 @@
+export interface Queue {
+    queueId: string;
+    jobs: Job[];
+}
+export interface Job {
+    jobId: string;
+    process: (data: any, progress: Progress) => Promise<void>;
+}
+export type Progress = (current: number, total: number) => void;

package/mq/queue.js

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

package/mq/queue.ts

@@ -0,0 +1,11 @@
+export interface Queue {
+  queueId: string,
+  jobs: Job[],
+}
+
+export interface Job {
+  jobId: string,
+  process: (data: any, progress: Progress) => Promise<void>,
+}
+
+export type Progress = (current: number, total: number) => void

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "apeframework",
+  "version": "0.0.0-dev.1",
+  "license": "MIT",
+  "author": "Matthieu Symoens",
+  "description": "Node.js API framework.",
+  "keywords": [
+    "ape",
+    "framework"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ApeCommerce/ape-framework.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"
+  },
+  "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",
+    "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",
+    "yargs-parser": "^21.1"
+  }
+}

package/pwd/config.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    hashCost: number;
+};
+export default _default;

package/pwd/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../config");
+var config = (0, config_1.getConfig)();
+if (!config.pwdHashCost)
+    throw new Error('pwd: hash cost not provided');
+exports.default = {
+    hashCost: config.pwdHashCost,
+};

package/pwd/config.ts

@@ -0,0 +1,9 @@
+import { getConfig } from '../config'
+
+const config = getConfig()
+
+if (!config.pwdHashCost) throw new Error('pwd: hash cost not provided')
+
+export default {
+  hashCost: config.pwdHashCost,
+}

package/pwd/index.d.ts

@@ -0,0 +1,6 @@
+import type { Pwd } from './pwd';
+export { Pwd };
+export declare const hashPassword: (password: string) => Promise<string>;
+export declare const verifyPassword: (password: string, hash: string) => Promise<boolean>;
+declare const pwd: Pwd;
+export default pwd;

package/pwd/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPassword = exports.hashPassword = void 0;
+var bcrypt_1 = __importDefault(require("bcrypt"));
+var config_1 = __importDefault(require("./config"));
+var hashPassword = function (password) {
+    return bcrypt_1.default.hash(password, config_1.default.hashCost);
+};
+exports.hashPassword = hashPassword;
+var verifyPassword = function (password, hash) {
+    return bcrypt_1.default.compare(password, hash);
+};
+exports.verifyPassword = verifyPassword;
+var pwd = {
+    hashPassword: exports.hashPassword,
+    verifyPassword: exports.verifyPassword,
+};
+exports.default = pwd;

package/pwd/index.ts

@@ -0,0 +1,20 @@
+import bcrypt from 'bcrypt'
+import config from './config'
+import type { Pwd } from './pwd'
+
+export { Pwd }
+
+export const hashPassword = (password: string) => {
+  return bcrypt.hash(password, config.hashCost)
+}
+
+export const verifyPassword = (password: string, hash: string) => {
+  return bcrypt.compare(password, hash)
+}
+
+const pwd: Pwd = {
+  hashPassword,
+  verifyPassword,
+}
+
+export default pwd

package/pwd/pwd.d.ts

@@ -0,0 +1,4 @@
+export interface Pwd {
+    hashPassword: (password: string) => Promise<string>;
+    verifyPassword: (password: string, hash: string) => Promise<boolean>;
+}

package/pwd/pwd.js

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

package/pwd/pwd.ts

@@ -0,0 +1,4 @@
+export interface Pwd {
+  hashPassword: (password: string) => Promise<string>,
+  verifyPassword: (password: string, hash: string) => Promise<boolean>,
+}

package/utils/index.d.ts

@@ -0,0 +1,25 @@
+export declare const parseBoolean: (value: any) => boolean;
+export declare const parseNumber: (value: any) => number;
+export declare const parseString: (value: any) => string;
+export declare const basePath: (path?: string, separator?: string) => string;
+export declare const parseBytes: (value: any) => number;
+export declare const parseMilliseconds: (value: any) => number;
+export declare const parseSeconds: (value: any) => number;
+export declare const randomString: (length: number) => string;
+export declare const timestamp: () => number;
+export declare const uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+export declare const wait: (milliseconds: number) => Promise<void>;
+declare const _default: {
+    basePath: (path?: string | undefined, separator?: string) => string;
+    parseBoolean: (value: any) => boolean;
+    parseBytes: (value: any) => number;
+    parseMilliseconds: (value: any) => number;
+    parseNumber: (value: any) => number;
+    parseSeconds: (value: any) => number;
+    parseString: (value: any) => string;
+    randomString: (length: number) => string;
+    timestamp: () => number;
+    uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    wait: (milliseconds: number) => Promise<void>;
+};
+export default _default;

package/utils/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = exports.uuid = exports.timestamp = exports.randomString = exports.parseSeconds = exports.parseMilliseconds = exports.parseBytes = exports.basePath = exports.parseString = exports.parseNumber = exports.parseBoolean = void 0;
+var crypto_1 = require("crypto");
+var bytes_1 = __importDefault(require("bytes"));
+var parse_duration_1 = __importDefault(require("parse-duration"));
+var parseBoolean = function (value) {
+    return value === true || value === 1 || value === '1';
+};
+exports.parseBoolean = parseBoolean;
+var parseNumber = function (value) {
+    return value === true ? 0 : Number(value) || 0;
+};
+exports.parseNumber = parseNumber;
+var parseString = function (value) {
+    return ['boolean', 'function', 'object'].includes(typeof value)
+        ? ''
+        : value === 0 ? '0' : String(value || '');
+};
+exports.parseString = parseString;
+var basePath = function (path, separator) {
+    if (separator === void 0) { separator = '/'; }
+    return (0, exports.parseString)(path).split(separator).filter(function (value) { return value; })[0] || '';
+};
+exports.basePath = basePath;
+var parseBytes = function (value) {
+    return (0, bytes_1.default)((0, exports.parseString)(value)) || 0;
+};
+exports.parseBytes = parseBytes;
+var parseMilliseconds = function (value) {
+    var _a;
+    return Math.floor((_a = (0, parse_duration_1.default)((0, exports.parseString)(value))) !== null && _a !== void 0 ? _a : 0);
+};
+exports.parseMilliseconds = parseMilliseconds;
+var parseSeconds = function (value) {
+    return Math.floor((0, exports.parseNumber)(value) || (0, exports.parseMilliseconds)(value) / 1000);
+};
+exports.parseSeconds = parseSeconds;
+var randomString = function (length) {
+    return (0, crypto_1.randomBytes)(length / 2 + 1).toString('hex').substring(0, length);
+};
+exports.randomString = randomString;
+var timestamp = function () {
+    return Math.floor(Date.now() / 1000);
+};
+exports.timestamp = timestamp;
+var uuid = function () {
+    return (0, crypto_1.randomUUID)();
+};
+exports.uuid = uuid;
+var wait = function (milliseconds) {
+    return new Promise(function (resolve) { return setTimeout(function () {
+        resolve();
+    }, milliseconds); });
+};
+exports.wait = wait;
+exports.default = {
+    basePath: exports.basePath,
+    parseBoolean: exports.parseBoolean,
+    parseBytes: exports.parseBytes,
+    parseMilliseconds: exports.parseMilliseconds,
+    parseNumber: exports.parseNumber,
+    parseSeconds: exports.parseSeconds,
+    parseString: exports.parseString,
+    randomString: exports.randomString,
+    timestamp: exports.timestamp,
+    uuid: exports.uuid,
+    wait: exports.wait,
+};

package/utils/index.ts

@@ -0,0 +1,56 @@
+import { randomBytes, randomUUID } from 'crypto'
+import bytes from 'bytes'
+import parseDuration from 'parse-duration'
+
+export const parseBoolean = (value: any) => {
+  return value === true || value === 1 || value === '1'
+}
+export const parseNumber = (value: any) => {
+  return value === true ? 0 : Number(value) || 0
+}
+export const parseString = (value: any) => {
+  return ['boolean', 'function', 'object'].includes(typeof value)
+    ? ''
+    : value === 0 ? '0' : String(value || '')
+}
+
+export const basePath = (path?: string, separator = '/') => {
+  return parseString(path).split(separator).filter((value) => value)[0] || ''
+}
+export const parseBytes = (value: any) => {
+  return bytes(parseString(value)) || 0
+}
+export const parseMilliseconds = (value: any) => {
+  return Math.floor(parseDuration(parseString(value)) ?? 0)
+}
+export const parseSeconds = (value: any) => {
+  return Math.floor(parseNumber(value) || parseMilliseconds(value) / 1000)
+}
+export const randomString = (length: number) => {
+  return randomBytes(length / 2 + 1).toString('hex').substring(0, length)
+}
+export const timestamp = () => {
+  return Math.floor(Date.now() / 1000)
+}
+export const uuid = () => {
+  return randomUUID()
+}
+export const wait = (milliseconds: number) => {
+  return new Promise<void>((resolve) => setTimeout(() => {
+    resolve()
+  }, milliseconds))
+}
+
+export default {
+  basePath,
+  parseBoolean,
+  parseBytes,
+  parseMilliseconds,
+  parseNumber,
+  parseSeconds,
+  parseString,
+  randomString,
+  timestamp,
+  uuid,
+  wait,
+}