apeframework 0.0.0-dev.1

package/i18n/index.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getI18n = exports.initI18n = void 0;
+var i18next_1 = __importStar(require("i18next"));
+var app_1 = require("../app");
+var config_1 = __importDefault(require("./config"));
+var getNamespaces = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, (0, app_1.getBundles)()];
+        case 1: return [2 /*return*/, (_a.sent()).map(function (bundle) { return bundle.bundleId; })];
+    }
+}); }); };
+var getResources = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var resources, _loop_1, _i, _a, bundle;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                resources = {};
+                _loop_1 = function (bundle) {
+                    var _c;
+                    return __generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                if (!bundle.translations) return [3 /*break*/, 2];
+                                return [4 /*yield*/, bundle.translations()];
+                            case 1:
+                                _c = _d.sent();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                _c = [];
+                                _d.label = 3;
+                            case 3:
+                                (_c).forEach(function (translation) {
+                                    if (!(translation.languageId in resources))
+                                        resources[translation.languageId] = {};
+                                    resources[translation.languageId][bundle.bundleId] = translation.dictionary;
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                };
+                _i = 0;
+                return [4 /*yield*/, (0, app_1.getBundles)()];
+            case 1:
+                _a = _b.sent();
+                _b.label = 2;
+            case 2:
+                if (!(_i < _a.length)) return [3 /*break*/, 5];
+                bundle = _a[_i];
+                return [5 /*yield**/, _loop_1(bundle)];
+            case 3:
+                _b.sent();
+                _b.label = 4;
+            case 4:
+                _i++;
+                return [3 /*break*/, 2];
+            case 5: return [2 /*return*/, resources];
+        }
+    });
+}); };
+var internalization;
+var initI18n = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = i18next_1.init;
+                _b = {};
+                return [4 /*yield*/, getNamespaces()];
+            case 1:
+                _b.ns = _c.sent();
+                return [4 /*yield*/, getResources()];
+            case 2: return [4 /*yield*/, _a.apply(void 0, [(_b.resources = _c.sent(),
+                        _b.fallbackLng = config_1.default.fallbackLanguage,
+                        _b)])];
+            case 3:
+                _c.sent();
+                internalization = i18next_1.default;
+                return [2 /*return*/, internalization];
+        }
+    });
+}); };
+exports.initI18n = initI18n;
+var getI18n = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    return [2 /*return*/, internalization !== null && internalization !== void 0 ? internalization : (0, exports.initI18n)()];
+}); }); };
+exports.getI18n = getI18n;
+var i18n = {
+    getI18n: exports.getI18n,
+    initI18n: exports.initI18n,
+};
+exports.default = i18n;

package/i18n/index.ts

@@ -0,0 +1,42 @@
+import i18next, { init, Resource as Resources } from 'i18next'
+import { getBundles } from '../app'
+import config from './config'
+import type { I18n } from './i18n'
+import type { Internationalization } from './internationalization'
+import type { Translation } from './translation'
+
+export { I18n, Internationalization, Translation }
+
+const getNamespaces = async () => (await getBundles()).map((bundle) => bundle.bundleId)
+
+const getResources = async () => {
+  const resources: Resources = {}
+  for (const bundle of await getBundles()) {
+    (bundle.translations ? await bundle.translations() : []).forEach((translation) => {
+      if (!(translation.languageId in resources)) resources[translation.languageId] = {}
+      resources[translation.languageId][bundle.bundleId] = translation.dictionary
+    })
+  }
+  return resources
+}
+
+let internalization: Internationalization | undefined
+
+export const initI18n = async () => {
+  await init({
+    ns: await getNamespaces(),
+    resources: await getResources(),
+    fallbackLng: config.fallbackLanguage,
+  })
+  internalization = i18next
+  return internalization
+}
+
+export const getI18n = async () => internalization ?? initI18n()
+
+const i18n: I18n = {
+  getI18n,
+  initI18n,
+}
+
+export default i18n

package/i18n/internationalization.d.ts

@@ -0,0 +1,3 @@
+import type { i18n as Internationalization } from 'i18next';
+export { Internationalization };
+export default Internationalization;

package/i18n/internationalization.js

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

package/i18n/internationalization.ts

@@ -0,0 +1,5 @@
+import type { i18n as Internationalization } from 'i18next'
+
+export { Internationalization }
+
+export default Internationalization

package/i18n/translation.d.ts

@@ -0,0 +1,4 @@
+export interface Translation {
+    languageId: string;
+    dictionary: any;
+}

package/i18n/translation.js

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

package/i18n/translation.ts

@@ -0,0 +1,4 @@
+export interface Translation {
+  languageId: string,
+  dictionary: any,
+}

package/jwt/config.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    issuer: string;
+    secret: string;
+};
+export default _default;

package/jwt/config.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../config");
+var config = (0, config_1.getConfig)();
+if (!config.jwtIssuer)
+    throw new Error('jwt: issuer not provided');
+if (!config.jwtSecret)
+    throw new Error('jwt: secret not provided');
+exports.default = {
+    issuer: config.jwtIssuer,
+    secret: config.jwtSecret,
+};

package/jwt/config.ts

@@ -0,0 +1,11 @@
+import { getConfig } from '../config'
+
+const config = getConfig()
+
+if (!config.jwtIssuer) throw new Error('jwt: issuer not provided')
+if (!config.jwtSecret) throw new Error('jwt: secret not provided')
+
+export default {
+  issuer: config.jwtIssuer,
+  secret: config.jwtSecret,
+}

package/jwt/index.d.ts

@@ -0,0 +1,8 @@
+import type { Jwt } from './jwt';
+import type { User } from './user';
+export { Jwt, User };
+export declare const createToken: (user: User, type: string, timestamp: number, expiration: number) => Promise<string>;
+export declare const verifyToken: (token: string, type: string, timestamp: number) => Promise<User | undefined>;
+export declare const hasRoles: (user: User, roles: string[]) => boolean;
+declare const jwt: Jwt;
+export default jwt;

package/jwt/index.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRoles = exports.verifyToken = exports.createToken = void 0;
+var jose_1 = require("jose");
+var config_1 = __importDefault(require("./config"));
+var log_1 = __importDefault(require("../log"));
+var secret = new TextEncoder().encode(config_1.default.secret);
+var createToken = function (user, type, timestamp, expiration) { return __awaiter(void 0, void 0, void 0, function () {
+    var payload;
+    return __generator(this, function (_a) {
+        payload = { type: type, user: user };
+        return [2 /*return*/, new jose_1.SignJWT(payload)
+                .setProtectedHeader({ typ: 'JWT', alg: 'HS256' })
+                .setIssuer(config_1.default.issuer)
+                .setIssuedAt(timestamp)
+                .setExpirationTime(timestamp + expiration)
+                .sign(secret)];
+    });
+}); };
+exports.createToken = createToken;
+var verifyToken = function (token, type, timestamp) { return __awaiter(void 0, void 0, void 0, function () {
+    var payload, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, (0, jose_1.jwtVerify)(token, secret, {
+                        algorithms: ['HS256'],
+                        issuer: config_1.default.issuer,
+                        currentDate: new Date(timestamp * 1000),
+                    })];
+            case 1:
+                payload = (_a.sent()).payload;
+                return [2 /*return*/, payload.type === type ? payload.user : undefined];
+            case 2:
+                error_1 = _a.sent();
+                log_1.default.debug(error_1);
+                return [2 /*return*/, undefined];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+exports.verifyToken = verifyToken;
+var hasRoles = function (user, roles) { return roles.every(function (role) { return user.roles.includes(role); }); };
+exports.hasRoles = hasRoles;
+var jwt = {
+    createToken: exports.createToken,
+    hasRoles: exports.hasRoles,
+    verifyToken: exports.verifyToken,
+};
+exports.default = jwt;

package/jwt/index.ts

@@ -0,0 +1,60 @@
+import { jwtVerify, JWTPayload, ProtectedHeaderParameters as Header, SignJWT } from 'jose'
+import config from './config'
+import log from '../log'
+import type { Jwt } from './jwt'
+import type { User } from './user'
+
+export { Jwt, User }
+
+interface Payload extends JWTPayload {
+  type: string,
+  user: User,
+}
+
+const secret = new TextEncoder().encode(config.secret)
+
+export const createToken = async (
+  user: User,
+  type: string,
+  timestamp: number,
+  expiration: number,
+) => {
+  const payload: Payload = { type, user }
+  return new SignJWT(payload)
+    .setProtectedHeader({ typ: 'JWT', alg: 'HS256' })
+    .setIssuer(config.issuer)
+    .setIssuedAt(timestamp)
+    .setExpirationTime(timestamp + expiration)
+    .sign(secret)
+}
+
+export const verifyToken = async (
+  token: string,
+  type: string,
+  timestamp: number,
+) => {
+  try {
+    const { payload } = (await jwtVerify(token, secret, {
+      algorithms: ['HS256'],
+      issuer: config.issuer,
+      currentDate: new Date(timestamp * 1000),
+    })) as { payload: Payload, protectedHeader: Header }
+    return payload.type === type ? payload.user : undefined
+  } catch (error) {
+    log.debug(error)
+    return undefined
+  }
+}
+
+export const hasRoles = (
+  user: User,
+  roles: string[],
+) => roles.every((role) => user.roles.includes(role))
+
+const jwt: Jwt = {
+  createToken,
+  hasRoles,
+  verifyToken,
+}
+
+export default jwt

package/jwt/jwt.d.ts

@@ -0,0 +1,6 @@
+import type { User } from './user';
+export interface Jwt {
+    createToken: (user: User, type: string, timestamp: number, expiration: number) => Promise<string>;
+    hasRoles: (user: User, roles: string[]) => boolean;
+    verifyToken: (token: string, type: string, timestamp: number) => Promise<User | undefined>;
+}

package/jwt/jwt.js

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

package/jwt/jwt.ts

@@ -0,0 +1,19 @@
+import type { User } from './user'
+
+export interface Jwt {
+  createToken: (
+    user: User,
+    type: string,
+    timestamp: number,
+    expiration: number
+  ) => Promise<string>,
+  hasRoles: (
+    user: User,
+    roles: string[]
+  ) => boolean,
+  verifyToken: (
+    token: string,
+    type: string,
+    timestamp: number
+  ) => Promise<User | undefined>,
+}

package/jwt/user.d.ts

@@ -0,0 +1,4 @@
+export interface User {
+    userId: string;
+    roles: string[];
+}

package/jwt/user.js

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

package/jwt/user.ts

@@ -0,0 +1,4 @@
+export interface User {
+  userId: string,
+  roles: string[],
+}

package/log/config.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { LoggerOptions as Options } from 'pino';
+import pretty from 'pino-pretty';
+export declare enum Level {
+    debug = "debug",
+    error = "error",
+    fatal = "fatal",
+    info = "info",
+    silent = "silent",
+    trace = "trace",
+    warn = "warn"
+}
+export declare enum Destination {
+    file = "file",
+    stdout = "stdout"
+}
+declare const _default: {
+    options: Options<never>;
+    stream: (NodeJS.WriteStream & {
+        fd: 1;
+    }) | import("sonic-boom").default | pretty.PrettyStream;
+};
+export default _default;

package/log/config.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Destination = exports.Level = void 0;
+var pino_1 = __importDefault(require("pino"));
+var pino_pretty_1 = __importDefault(require("pino-pretty"));
+var config_1 = require("../config");
+var Level;
+(function (Level) {
+    Level["debug"] = "debug";
+    Level["error"] = "error";
+    Level["fatal"] = "fatal";
+    Level["info"] = "info";
+    Level["silent"] = "silent";
+    Level["trace"] = "trace";
+    Level["warn"] = "warn";
+})(Level || (exports.Level = Level = {}));
+var Destination;
+(function (Destination) {
+    Destination["file"] = "file";
+    Destination["stdout"] = "stdout";
+})(Destination || (exports.Destination = Destination = {}));
+var config = (0, config_1.getConfig)();
+var level = Object.values(Level)
+    .find(function (level) { return level === config.logLevel; });
+if (!level)
+    throw new Error("log: invalid level \"".concat(config.logLevel, "\""));
+var destination = Object.values(Destination)
+    .find(function (destination) { return destination === config.logDestination; });
+if (!destination)
+    throw new Error("log: invalid destination \"".concat(config.logDestination, "\""));
+var options = { level: level };
+var stream;
+if (destination === Destination.file) {
+    if (!config.logFile)
+        throw new Error('log: file not provided');
+    stream = pino_1.default.destination(config.logFile);
+}
+else {
+    stream = config.logPretty ? (0, pino_pretty_1.default)() : process.stdout;
+}
+exports.default = {
+    options: options,
+    stream: stream,
+};

package/log/config.ts

@@ -0,0 +1,43 @@
+import pino, { LoggerOptions as Options } from 'pino'
+import pretty from 'pino-pretty'
+import { getConfig } from '../config'
+
+export enum Level {
+  debug = 'debug',
+  error = 'error',
+  fatal = 'fatal',
+  info = 'info',
+  silent = 'silent',
+  trace = 'trace',
+  warn = 'warn',
+}
+
+export enum Destination {
+  file = 'file',
+  stdout = 'stdout',
+}
+
+const config = getConfig()
+
+const level = Object.values(Level)
+  .find((level: string) => level === config.logLevel)
+if (!level) throw new Error(`log: invalid level "${config.logLevel}"`)
+
+const destination = Object.values(Destination)
+  .find((destination: string) => destination === config.logDestination)
+if (!destination) throw new Error(`log: invalid destination "${config.logDestination}"`)
+
+const options: Options = { level }
+
+let stream
+if (destination === Destination.file) {
+  if (!config.logFile) throw new Error('log: file not provided')
+  stream = pino.destination(config.logFile)
+} else {
+  stream = config.logPretty ? pretty() : process.stdout
+}
+
+export default {
+  options,
+  stream,
+}

package/log/index.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from './logger';
+export { Logger };
+declare const logger: Logger;
+export default logger;

package/log/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var pino_1 = __importDefault(require("pino"));
+var config_1 = __importDefault(require("./config"));
+var logger = (0, pino_1.default)(config_1.default.options, config_1.default.stream);
+exports.default = logger;

package/log/index.ts

@@ -0,0 +1,9 @@
+import pino from 'pino'
+import config from './config'
+import type { Logger } from './logger'
+
+export { Logger }
+
+const logger: Logger = pino(config.options, config.stream)
+
+export default logger

package/log/logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from 'pino';
+export { Logger };
+export default Logger;

package/log/logger.js

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

package/log/logger.ts

@@ -0,0 +1,5 @@
+import type { Logger } from 'pino'
+
+export { Logger }
+
+export default Logger

package/mail/config.d.ts

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

package/mail/config.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    theme: 'default',
+};

package/mail/config.ts

@@ -0,0 +1,3 @@
+export default {
+  theme: 'default',
+}