apeframework 0.0.0-dev.1 → 0.0.0-dev.3

package/db/adapters/sqlite/driver.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driver = void 0;
+const driver = {
+    dataType: {
+        boolean: 'INTEGER',
+        tinyInt: 'INTEGER',
+        smallInt: 'INTEGER',
+        smallIntPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+        int: 'INTEGER',
+        intPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+        bigInt: 'INTEGER',
+        bigIntPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+        float: 'REAL',
+        double: 'REAL',
+        numeric: () => {
+            return 'NUMERIC';
+        },
+        char: () => {
+            return 'TEXT';
+        },
+        varChar: () => {
+            return 'TEXT';
+        },
+        tinyText: 'TEXT',
+        text: 'TEXT',
+        longText: 'TEXT',
+        binary: () => {
+            return 'BLOB';
+        },
+        varBinary: () => {
+            return 'BLOB';
+        },
+        tinyBlob: 'BLOB',
+        blob: 'BLOB',
+        longBlob: 'BLOB',
+        timestamp: 'TEXT',
+        dateTime: 'TEXT',
+        date: 'TEXT',
+        time: 'TEXT',
+    },
+};
+exports.driver = driver;

package/db/adapters/sqlite/driver.ts

@@ -0,0 +1,45 @@
+import type { Driver } from '../../Driver'
+
+const driver: Driver = {
+  dataType: {
+    boolean: 'INTEGER',
+    tinyInt: 'INTEGER',
+    smallInt: 'INTEGER',
+    smallIntPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+    int: 'INTEGER',
+    intPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+    bigInt: 'INTEGER',
+    bigIntPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+    float: 'REAL',
+    double: 'REAL',
+    numeric: () => {
+      return 'NUMERIC'
+    },
+    char: () => {
+      return 'TEXT'
+    },
+    varChar: () => {
+      return 'TEXT'
+    },
+    tinyText: 'TEXT',
+    text: 'TEXT',
+    longText: 'TEXT',
+    binary: () => {
+      return 'BLOB'
+    },
+    varBinary: () => {
+      return 'BLOB'
+    },
+    tinyBlob: 'BLOB',
+    blob: 'BLOB',
+    longBlob: 'BLOB',
+    timestamp: 'TEXT',
+    dateTime: 'TEXT',
+    date: 'TEXT',
+    time: 'TEXT',
+  },
+}
+
+export {
+  driver,
+}

package/db/errors/DbColumnLengthError.d.ts

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

package/db/errors/DbColumnLengthError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbColumnLengthError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class DbColumnLengthError extends BaseError_1.BaseError {
+    constructor(length) {
+        super(`invalid column length "${length}"`);
+    }
+}
+exports.DbColumnLengthError = DbColumnLengthError;

package/db/errors/DbColumnLengthError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class DbColumnLengthError extends BaseError {
+  public constructor(length: number) {
+    super(`invalid column length "${length}"`)
+  }
+}
+
+export {
+  DbColumnLengthError,
+}

package/db/errors/DbColumnMaxLengthError.d.ts

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

package/db/errors/DbColumnMaxLengthError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbColumnMaxLengthError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class DbColumnMaxLengthError extends BaseError_1.BaseError {
+    constructor(maxLength) {
+        super(`invalid column max length "${maxLength}"`);
+    }
+}
+exports.DbColumnMaxLengthError = DbColumnMaxLengthError;

package/db/errors/DbColumnMaxLengthError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class DbColumnMaxLengthError extends BaseError {
+  public constructor(maxLength: number) {
+    super(`invalid column max length "${maxLength}"`)
+  }
+}
+
+export {
+  DbColumnMaxLengthError,
+}

package/db/errors/DbColumnPrecisionError.d.ts

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

package/db/errors/DbColumnPrecisionError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbColumnPrecisionError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class DbColumnPrecisionError extends BaseError_1.BaseError {
+    constructor(precision) {
+        super(`invalid column precision "${precision}"`);
+    }
+}
+exports.DbColumnPrecisionError = DbColumnPrecisionError;

package/db/errors/DbColumnPrecisionError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class DbColumnPrecisionError extends BaseError {
+  public constructor(precision: number) {
+    super(`invalid column precision "${precision}"`)
+  }
+}
+
+export {
+  DbColumnPrecisionError,
+}

package/db/errors/DbColumnScaleError.d.ts

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

package/db/errors/DbColumnScaleError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbColumnScaleError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class DbColumnScaleError extends BaseError_1.BaseError {
+    constructor(scale) {
+        super(`invalid column scale "${scale}"`);
+    }
+}
+exports.DbColumnScaleError = DbColumnScaleError;

package/db/errors/DbColumnScaleError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class DbColumnScaleError extends BaseError {
+  public constructor(scale: number) {
+    super(`invalid column scale "${scale}"`)
+  }
+}
+
+export {
+  DbColumnScaleError,
+}

package/db/getConstraintName.d.ts

@@ -0,0 +1,2 @@
+declare const getConstraintName: (constraint: string, table: string, columns: string[]) => string;
+export { getConstraintName, };

package/db/getConstraintName.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstraintName = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const getConstraintName = (constraint, table, columns) => {
+    const hash = crypto_1.default
+        .createHash('md5')
+        .update([table, ...columns].join('_'))
+        .digest('hex');
+    return `${constraint}_${hash}`;
+};
+exports.getConstraintName = getConstraintName;

package/db/getConstraintName.ts

@@ -0,0 +1,18 @@
+import crypto from 'crypto'
+
+const getConstraintName = (
+  constraint: string,
+  table: string,
+  columns: string[],
+): string => {
+  const hash = crypto
+    .createHash('md5')
+    .update([table, ...columns].join('_'))
+    .digest('hex')
+
+  return `${constraint}_${hash}`
+}
+
+export {
+  getConstraintName,
+}

package/db/getReferentialActionSql.d.ts

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

package/db/getReferentialActionSql.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferentialActionSql = void 0;
+const sql = {
+    cascade: 'CASCADE',
+    restrict: 'RESTRICT',
+    setNull: 'SET NULL',
+};
+const getReferentialActionSql = (referentialAction) => {
+    return sql[referentialAction];
+};
+exports.getReferentialActionSql = getReferentialActionSql;

package/db/getReferentialActionSql.ts

@@ -0,0 +1,17 @@
+import type { ReferentialAction } from './ReferentialAction'
+
+const sql: Record<ReferentialAction, string> = {
+  cascade: 'CASCADE',
+  restrict: 'RESTRICT',
+  setNull: 'SET NULL',
+}
+
+const getReferentialActionSql = (
+  referentialAction: ReferentialAction,
+): string => {
+  return sql[referentialAction]
+}
+
+export {
+  getReferentialActionSql,
+}

package/db/setNullConstraint.d.ts

@@ -0,0 +1,4 @@
+import type { NullConstraint } from './NullConstraint';
+import type { Knex } from 'knex';
+declare const setNullConstraint: (knexColumnBuilder: Knex.ColumnBuilder, nullConstraint: NullConstraint) => void;
+export { setNullConstraint, };

package/db/setNullConstraint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNullConstraint = void 0;
+const setNullConstraint = (knexColumnBuilder, nullConstraint) => {
+    if (nullConstraint === 'notNull') {
+        knexColumnBuilder.notNullable();
+    }
+};
+exports.setNullConstraint = setNullConstraint;

package/db/setNullConstraint.ts

@@ -0,0 +1,15 @@
+import type { NullConstraint } from './NullConstraint'
+import type { Knex } from 'knex'
+
+const setNullConstraint = (
+  knexColumnBuilder: Knex.ColumnBuilder,
+  nullConstraint: NullConstraint,
+): void => {
+  if (nullConstraint === 'notNull') {
+    knexColumnBuilder.notNullable()
+  }
+}
+
+export {
+  setNullConstraint,
+}

package/db/validateColumnLength.d.ts

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

package/db/validateColumnLength.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColumnLength = void 0;
+const DbColumnLengthError_1 = require("./errors/DbColumnLengthError");
+const validateColumnLength = (length) => {
+    if (length < 1 || length > 255) {
+        throw new DbColumnLengthError_1.DbColumnLengthError(length);
+    }
+};
+exports.validateColumnLength = validateColumnLength;

package/db/validateColumnLength.ts

@@ -0,0 +1,11 @@
+import { DbColumnLengthError } from './errors/DbColumnLengthError'
+
+const validateColumnLength = (length: number): void => {
+  if (length < 1 || length > 255) {
+    throw new DbColumnLengthError(length)
+  }
+}
+
+export {
+  validateColumnLength,
+}

package/db/validateColumnMaxLength.d.ts

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

package/db/validateColumnMaxLength.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColumnMaxLength = void 0;
+const DbColumnMaxLengthError_1 = require("./errors/DbColumnMaxLengthError");
+const validateColumnMaxLength = (maxLength) => {
+    if (maxLength < 1 || maxLength > 65535) {
+        throw new DbColumnMaxLengthError_1.DbColumnMaxLengthError(maxLength);
+    }
+};
+exports.validateColumnMaxLength = validateColumnMaxLength;

package/db/validateColumnMaxLength.ts

@@ -0,0 +1,11 @@
+import { DbColumnMaxLengthError } from './errors/DbColumnMaxLengthError'
+
+const validateColumnMaxLength = (maxLength: number): void => {
+  if (maxLength < 1 || maxLength > 65535) {
+    throw new DbColumnMaxLengthError(maxLength)
+  }
+}
+
+export {
+  validateColumnMaxLength,
+}

package/db/validateColumnPrecision.d.ts

@@ -0,0 +1,2 @@
+declare const validateColumnPrecision: (precision: number, scale: number) => void;
+export { validateColumnPrecision, };

package/db/validateColumnPrecision.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColumnPrecision = void 0;
+const DbColumnPrecisionError_1 = require("./errors/DbColumnPrecisionError");
+const DbColumnScaleError_1 = require("./errors/DbColumnScaleError");
+const validateColumnPrecision = (precision, scale) => {
+    if (precision < 1 || precision > 15) {
+        throw new DbColumnPrecisionError_1.DbColumnPrecisionError(precision);
+    }
+    if (scale < 0 || scale >= precision) {
+        throw new DbColumnScaleError_1.DbColumnScaleError(scale);
+    }
+};
+exports.validateColumnPrecision = validateColumnPrecision;

package/db/validateColumnPrecision.ts

@@ -0,0 +1,15 @@
+import { DbColumnPrecisionError } from './errors/DbColumnPrecisionError'
+import { DbColumnScaleError } from './errors/DbColumnScaleError'
+
+const validateColumnPrecision = (precision: number, scale: number): void => {
+  if (precision < 1 || precision > 15) {
+    throw new DbColumnPrecisionError(precision)
+  }
+  if (scale < 0 || scale >= precision) {
+    throw new DbColumnScaleError(scale)
+  }
+}
+
+export {
+  validateColumnPrecision,
+}

package/env/Env.d.ts

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

package/env/Env.ts

@@ -0,0 +1,5 @@
+type Env = Record<string, string>
+
+export {
+  type Env,
+}

package/env/errors/EnvFileReadError.d.ts

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

package/env/errors/EnvFileReadError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvFileReadError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class EnvFileReadError extends BaseError_1.BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+exports.EnvFileReadError = EnvFileReadError;

package/env/errors/EnvFileReadError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class EnvFileReadError extends BaseError {
+  public constructor(path: string, message: string) {
+    super(`failed reading file "${path}": ${message}`)
+  }
+}
+
+export {
+  EnvFileReadError,
+}

package/env/getEnv.d.ts

@@ -0,0 +1,8 @@
+import type { Env } from './Env';
+declare const getEnv: (params?: {
+    file?: {
+        path: string;
+        required?: boolean;
+    };
+}) => Env;
+export { getEnv, };

package/env/getEnv.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnv = void 0;
+const readFile_1 = require("./readFile");
+const getEnv = (params) => {
+    let file = {};
+    if (params?.file) {
+        file = (0, readFile_1.readFile)(params.file.path, params.file.required);
+    }
+    return {
+        ...file,
+        ...process.env,
+    };
+};
+exports.getEnv = getEnv;

package/env/getEnv.ts

@@ -0,0 +1,24 @@
+import { readFile } from './readFile'
+import type { Env } from './Env'
+
+const getEnv = (params?: {
+  file?: {
+    path: string,
+    required?: boolean,
+  },
+}): Env => {
+  let file: Env = {}
+
+  if (params?.file) {
+    file = readFile(params.file.path, params.file.required)
+  }
+
+  return {
+    ...file,
+    ...process.env as Env,
+  }
+}
+
+export {
+  getEnv,
+}

package/env/readFile.d.ts

@@ -0,0 +1,3 @@
+import type { Env } from './Env';
+declare const readFile: (path: string, required?: boolean) => Env;
+export { readFile, };

package/env/readFile.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const EnvFileReadError_1 = require("./errors/EnvFileReadError");
+const readFile = (path, required = false) => {
+    try {
+        if (fs_extra_1.default.existsSync(path)) {
+            return dotenv_1.default.parse(fs_extra_1.default.readFileSync(path));
+        }
+    }
+    catch (error) {
+        throw new EnvFileReadError_1.EnvFileReadError(path, error.message);
+    }
+    if (required) {
+        throw new EnvFileReadError_1.EnvFileReadError(path, 'missing file');
+    }
+    return {};
+};
+exports.readFile = readFile;

package/env/readFile.ts

@@ -0,0 +1,24 @@
+import dotenv from 'dotenv'
+import fs from 'fs-extra'
+import { EnvFileReadError } from './errors/EnvFileReadError'
+import type { Env } from './Env'
+
+const readFile = (path: string, required = false): Env => {
+  try {
+    if (fs.existsSync(path)) {
+      return dotenv.parse(fs.readFileSync(path))
+    }
+  } catch (error) {
+    throw new EnvFileReadError(path, (error as Error).message)
+  }
+
+  if (required) {
+    throw new EnvFileReadError(path, 'missing file')
+  }
+
+  return {}
+}
+
+export {
+  readFile,
+}

package/error/BaseError.d.ts

@@ -0,0 +1,4 @@
+declare class BaseError extends Error {
+    constructor(message: string);
+}
+export { BaseError, };

package/error/BaseError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+        Error.captureStackTrace(this, new.target);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.BaseError = BaseError;

package/error/BaseError.ts

@@ -0,0 +1,12 @@
+class BaseError extends Error {
+  public constructor(message: string) {
+    super(message)
+    this.name = new.target.name
+    Error.captureStackTrace(this, new.target)
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+export {
+  BaseError,
+}

package/jwt/Algorithm.d.ts

@@ -0,0 +1,6 @@
+declare enum Algorithm {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512"
+}
+export { Algorithm, };

package/jwt/Algorithm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Algorithm = void 0;
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["HS256"] = "HS256";
+    Algorithm["HS384"] = "HS384";
+    Algorithm["HS512"] = "HS512";
+})(Algorithm || (exports.Algorithm = Algorithm = {}));

package/jwt/Algorithm.ts

@@ -0,0 +1,9 @@
+enum Algorithm {
+  HS256 = 'HS256',
+  HS384 = 'HS384',
+  HS512 = 'HS512',
+}
+
+export {
+  Algorithm,
+}

package/jwt/Jwt.d.ts

@@ -0,0 +1,19 @@
+import type { Algorithm } from './Algorithm';
+import type { Payload } from './Payload';
+declare class Jwt {
+    private readonly algorithm;
+    private readonly secret;
+    private readonly issuer;
+    private readonly audience;
+    private readonly expiration;
+    constructor(params: {
+        algorithm: Algorithm;
+        secret: string;
+        issuer: string;
+        audience: string;
+        expiration?: number;
+    });
+    createToken(payload: Payload): Promise<string>;
+    verifyToken<Type extends Payload>(token: string, timestamp: number): Promise<Type | undefined>;
+}
+export { Jwt, };