apeframework 0.0.0-dev.3 → 0.0.0-dev.5

package/parser/parseNumber.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseNumber = void 0;
-const ParserInputError_1 = require("./errors/ParserInputError");
+const ParseError_1 = require("./errors/ParseError");
 const parseNumber = (input) => {
     if ([undefined, null].includes(input)) {
         return 0;
     }
     else if (['object', 'function', 'symbol'].includes(typeof input)) {
-        throw new ParserInputError_1.ParserInputError('number');
+        throw new ParseError_1.ParseError('number');
     }
     const number = Number(input);
     if (!Number.isFinite(number)) {
-        throw new ParserInputError_1.ParserInputError('number');
+        throw new ParseError_1.ParseError('number');
     }
     return number;
 };

package/parser/parseNumber.ts

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

package/parser/parseString.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseString = void 0;
-const ParserInputError_1 = require("./errors/ParserInputError");
+const ParseError_1 = require("./errors/ParseError");
 const parseString = (input) => {
     if ([undefined, null].includes(input)) {
         return '';
@@ -13,7 +13,7 @@ const parseString = (input) => {
         return '1';
     }
     else if (['object', 'function', 'symbol'].includes(typeof input)) {
-        throw new ParserInputError_1.ParserInputError('string');
+        throw new ParseError_1.ParseError('string');
     }
     return String(input);
 };

package/parser/parseString.ts

@@ -1,4 +1,4 @@
-import { ParserInputError } from './errors/ParserInputError'
+import { ParseError } from './errors/ParseError'
 import type { Parser } from './Parser'
 
 const parseString: Parser<string> = (input) => {
@@ -9,7 +9,7 @@ const parseString: Parser<string> = (input) => {
   } else if (input === true) {
     return '1'
   } else if (['object', 'function', 'symbol'].includes(typeof input)) {
-    throw new ParserInputError('string')
+    throw new ParseError('string')
   }
 
   return String(input)

package/pwd/errors/{PwdHashRoundsError.d.ts → HashRoundsError.d.ts}

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

package/pwd/errors/{PwdHashRoundsError.js → HashRoundsError.js}

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

package/pwd/errors/{PwdHashRoundsError.ts → HashRoundsError.ts}

@@ -1,11 +1,11 @@
 import { BaseError } from '../../error/BaseError'
 
-class PwdHashRoundsError extends BaseError {
+class HashRoundsError extends BaseError {
   public constructor(hashRounds: number) {
     super(`invalid hash rounds "${hashRounds}"`)
   }
 }
 
 export {
-  PwdHashRoundsError,
+  HashRoundsError,
 }

package/pwd/validateHashRounds.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateHashRounds = void 0;
-const PwdHashRoundsError_1 = require("./errors/PwdHashRoundsError");
+const HashRoundsError_1 = require("./errors/HashRoundsError");
 const validateHashRounds = (hashRounds) => {
     if (hashRounds < 1) {
-        throw new PwdHashRoundsError_1.PwdHashRoundsError(hashRounds);
+        throw new HashRoundsError_1.HashRoundsError(hashRounds);
     }
 };
 exports.validateHashRounds = validateHashRounds;

package/pwd/validateHashRounds.ts

@@ -1,8 +1,8 @@
-import { PwdHashRoundsError } from './errors/PwdHashRoundsError'
+import { HashRoundsError } from './errors/HashRoundsError'
 
 const validateHashRounds = (hashRounds: number): void => {
   if (hashRounds < 1) {
-    throw new PwdHashRoundsError(hashRounds)
+    throw new HashRoundsError(hashRounds)
   }
 }
 

package/{config/errors/ConfigFileReadError.d.ts → tls/errors/FileReadError.d.ts}

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

package/{config/errors/ConfigFileReadError.js → tls/errors/FileReadError.js}

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

package/{config/errors/ConfigFileReadError.ts → tls/errors/FileReadError.ts}

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

package/tls/readFile.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFile = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const TlsFileReadError_1 = require("./errors/TlsFileReadError");
+const FileReadError_1 = require("./errors/FileReadError");
 const readFile = (path) => {
     try {
         if (fs_extra_1.default.existsSync(path)) {
@@ -13,8 +13,8 @@ const readFile = (path) => {
         }
     }
     catch (error) {
-        throw new TlsFileReadError_1.TlsFileReadError(path, error.message);
+        throw new FileReadError_1.FileReadError(path, error.message);
     }
-    throw new TlsFileReadError_1.TlsFileReadError(path, 'missing file');
+    throw new FileReadError_1.FileReadError(path, 'missing file');
 };
 exports.readFile = readFile;

package/tls/readFile.ts

@@ -1,5 +1,5 @@
 import fs from 'fs-extra'
-import { TlsFileReadError } from './errors/TlsFileReadError'
+import { FileReadError } from './errors/FileReadError'
 
 const readFile = (path: string): string => {
   try {
@@ -7,10 +7,10 @@ const readFile = (path: string): string => {
       return fs.readFileSync(path).toString()
     }
   } catch (error) {
-    throw new TlsFileReadError(path, (error as Error).message)
+    throw new FileReadError(path, (error as Error).message)
   }
 
-  throw new TlsFileReadError(path, 'missing file')
+  throw new FileReadError(path, 'missing file')
 }
 
 export {

package/cipher/errors/CipherSecretLengthError.d.ts

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

package/cli/utils/write.d.ts

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

package/cli/utils/write.ts

@@ -1,7 +0,0 @@
-const write = (s: string): void => {
-  process.stdout.write(s)
-}
-
-export {
-  write,
-}

package/cli/utils/writeLn.d.ts

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

package/config/errors/ConfigParseError.d.ts

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

package/config/errors/ConfigParseError.js

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

package/config/errors/ConfigParseError.ts

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

package/config/errors/ConfigPropertyNameError.d.ts

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

package/db/ColumnBuilder.d.ts

@@ -1,13 +0,0 @@
-import type { ReferentialAction } from './ReferentialAction';
-import type { Knex } from 'knex';
-declare class ColumnBuilder {
-    private readonly table;
-    private readonly column;
-    private readonly knexColumnBuilder;
-    constructor(table: string, column: string, knexColumnBuilder: Knex.ColumnBuilder);
-    primary(): this;
-    foreign(referencedTable: string, referencedColumn: string, onUpdate: ReferentialAction, onDelete: ReferentialAction): this;
-    index(): this;
-    unique(): this;
-}
-export { ColumnBuilder, };

package/db/ColumnBuilder.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnBuilder = void 0;
-const getConstraintName_1 = require("./getConstraintName");
-const getReferentialActionSql_1 = require("./getReferentialActionSql");
-class ColumnBuilder {
-    table;
-    column;
-    knexColumnBuilder;
-    constructor(table, column, knexColumnBuilder) {
-        this.table = table;
-        this.column = column;
-        this.knexColumnBuilder = knexColumnBuilder;
-    }
-    primary() {
-        this.knexColumnBuilder.primary({
-            constraintName: 'PRIMARY',
-        });
-        return this;
-    }
-    foreign(referencedTable, referencedColumn, onUpdate, onDelete) {
-        this.knexColumnBuilder
-            .references(referencedColumn)
-            .inTable(referencedTable)
-            .onUpdate((0, getReferentialActionSql_1.getReferentialActionSql)(onUpdate))
-            .onDelete((0, getReferentialActionSql_1.getReferentialActionSql)(onDelete))
-            .withKeyName((0, getConstraintName_1.getConstraintName)('FOREIGN', this.table, [this.column]));
-        return this;
-    }
-    index() {
-        this.knexColumnBuilder
-            .index((0, getConstraintName_1.getConstraintName)('INDEX', this.table, [this.column]));
-        return this;
-    }
-    unique() {
-        this.knexColumnBuilder.unique({
-            indexName: (0, getConstraintName_1.getConstraintName)('UNIQUE', this.table, [this.column]),
-        });
-        return this;
-    }
-}
-exports.ColumnBuilder = ColumnBuilder;

package/db/ColumnBuilder.ts

@@ -1,61 +0,0 @@
-import { getConstraintName } from './getConstraintName'
-import { getReferentialActionSql } from './getReferentialActionSql'
-import type { ReferentialAction } from './ReferentialAction'
-import type { Knex } from 'knex'
-
-class ColumnBuilder {
-  private readonly table: string
-
-  private readonly column: string
-
-  private readonly knexColumnBuilder: Knex.ColumnBuilder
-
-  public constructor(
-    table: string,
-    column: string,
-    knexColumnBuilder: Knex.ColumnBuilder,
-  ) {
-    this.table = table
-    this.column = column
-    this.knexColumnBuilder = knexColumnBuilder
-  }
-
-  public primary(): this {
-    this.knexColumnBuilder.primary({
-      constraintName: 'PRIMARY',
-    })
-    return this
-  }
-
-  public foreign(
-    referencedTable: string,
-    referencedColumn: string,
-    onUpdate: ReferentialAction,
-    onDelete: ReferentialAction,
-  ): this {
-    this.knexColumnBuilder
-      .references(referencedColumn)
-      .inTable(referencedTable)
-      .onUpdate(getReferentialActionSql(onUpdate))
-      .onDelete(getReferentialActionSql(onDelete))
-      .withKeyName(getConstraintName('FOREIGN', this.table, [this.column]))
-    return this
-  }
-
-  public index(): this {
-    this.knexColumnBuilder
-      .index(getConstraintName('INDEX', this.table, [this.column]))
-    return this
-  }
-
-  public unique(): this {
-    this.knexColumnBuilder.unique({
-      indexName: getConstraintName('UNIQUE', this.table, [this.column]),
-    })
-    return this
-  }
-}
-
-export {
-  ColumnBuilder,
-}

package/db/Database.d.ts

@@ -1,19 +0,0 @@
-import { TableBuilder } from './TableBuilder';
-import type { Driver } from './Driver';
-import type { Knex } from 'knex';
-declare class Database {
-    private readonly knex;
-    private readonly driver;
-    constructor(knex: Knex, driver: Driver);
-    createTable(table: string, build: (tableBuilder: TableBuilder) => void): Promise<void>;
-    createTableLike(table: string, like: string, build: (tableBuilder: TableBuilder) => void): Promise<void>;
-    alterTable(table: string, build: (tableBuilder: TableBuilder) => void): Promise<void>;
-    dropTable(table: string): Promise<void>;
-    dropTableIfExists(table: string): Promise<void>;
-    renameTable(table: string, newName: string): Promise<void>;
-    hasTable(table: string): Promise<boolean>;
-    hasColumn(table: string, column: string): Promise<boolean>;
-    table<Type extends Knex>(table: string): Promise<Knex<Type>>;
-    from(table: Knex.Table): Promise<Knex.QueryBuilder>;
-}
-export { Database, };

package/db/Database.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Database = void 0;
-const TableBuilder_1 = require("./TableBuilder");
-class Database {
-    knex;
-    driver;
-    constructor(knex, driver) {
-        this.knex = knex;
-        this.driver = driver;
-    }
-    async createTable(table, build) {
-        return this.knex.schema.createTable(table, (knexTableBuilder) => {
-            build(new TableBuilder_1.TableBuilder(table, knexTableBuilder, this.driver));
-        });
-    }
-    async createTableLike(table, like, build) {
-        return this.knex.schema.createTableLike(table, like, (knexTableBuilder) => {
-            build(new TableBuilder_1.TableBuilder(table, knexTableBuilder, this.driver));
-        });
-    }
-    async alterTable(table, build) {
-        return this.knex.schema.alterTable(table, (knexTableBuilder) => {
-            build(new TableBuilder_1.TableBuilder(table, knexTableBuilder, this.driver));
-        });
-    }
-    async dropTable(table) {
-        return this.knex.schema.dropTable(table);
-    }
-    async dropTableIfExists(table) {
-        return this.knex.schema.dropTableIfExists(table);
-    }
-    async renameTable(table, newName) {
-        await this.knex.schema.renameTable(table, newName);
-    }
-    async hasTable(table) {
-        return this.knex.schema.hasTable(table);
-    }
-    async hasColumn(table, column) {
-        return this.knex.schema.hasColumn(table, column);
-    }
-    async table(table) {
-        return this.knex(table);
-    }
-    async from(table) {
-        return this.knex.from(table);
-    }
-}
-exports.Database = Database;

package/db/Database.ts

@@ -1,74 +0,0 @@
-import { TableBuilder } from './TableBuilder'
-import type { Driver } from './Driver'
-import type { Knex } from 'knex'
-
-class Database {
-  private readonly knex: Knex
-
-  private readonly driver: Driver
-
-  public constructor(knex: Knex, driver: Driver) {
-    this.knex = knex
-    this.driver = driver
-  }
-
-  public async createTable(
-    table: string,
-    build: (tableBuilder: TableBuilder) => void,
-  ): Promise<void> {
-    return this.knex.schema.createTable(table, (knexTableBuilder) => {
-      build(new TableBuilder(table, knexTableBuilder, this.driver))
-    })
-  }
-
-  public async createTableLike(
-    table: string,
-    like: string,
-    build: (tableBuilder: TableBuilder) => void,
-  ): Promise<void> {
-    return this.knex.schema.createTableLike(table, like, (knexTableBuilder) => {
-      build(new TableBuilder(table, knexTableBuilder, this.driver))
-    })
-  }
-
-  public async alterTable(
-    table: string,
-    build: (tableBuilder: TableBuilder) => void,
-  ): Promise<void> {
-    return this.knex.schema.alterTable(table, (knexTableBuilder) => {
-      build(new TableBuilder(table, knexTableBuilder, this.driver))
-    })
-  }
-
-  public async dropTable(table: string): Promise<void> {
-    return this.knex.schema.dropTable(table)
-  }
-
-  public async dropTableIfExists(table: string): Promise<void> {
-    return this.knex.schema.dropTableIfExists(table)
-  }
-
-  public async renameTable(table: string, newName: string): Promise<void> {
-    await this.knex.schema.renameTable(table, newName)
-  }
-
-  public async hasTable(table: string): Promise<boolean> {
-    return this.knex.schema.hasTable(table)
-  }
-
-  public async hasColumn(table: string, column: string): Promise<boolean> {
-    return this.knex.schema.hasColumn(table, column)
-  }
-
-  public async table<Type extends Knex>(table: string): Promise<Knex<Type>> {
-    return this.knex(table)
-  }
-
-  public async from(table: Knex.Table): Promise<Knex.QueryBuilder> {
-    return this.knex.from(table)
-  }
-}
-
-export {
-  Database,
-}

package/db/Driver.d.ts

@@ -1,30 +0,0 @@
-interface Driver {
-    dataType: {
-        boolean: string;
-        tinyInt: string;
-        smallInt: string;
-        smallIntPrimaryAutoIncrement: string;
-        int: string;
-        intPrimaryAutoIncrement: string;
-        bigInt: string;
-        bigIntPrimaryAutoIncrement: string;
-        float: string;
-        double: string;
-        numeric: (precision: number, scale: number) => string;
-        char: (length: number) => string;
-        varChar: (maxLength: number) => string;
-        tinyText: string;
-        text: string;
-        longText: string;
-        binary: (length: number) => string;
-        varBinary: (maxLength: number) => string;
-        tinyBlob: string;
-        blob: string;
-        longBlob: string;
-        timestamp: string;
-        dateTime: string;
-        date: string;
-        time: string;
-    };
-}
-export { type Driver, };

package/db/Driver.ts

@@ -1,33 +0,0 @@
-interface Driver {
-  dataType: {
-    boolean: string,
-    tinyInt: string,
-    smallInt: string,
-    smallIntPrimaryAutoIncrement: string,
-    int: string,
-    intPrimaryAutoIncrement: string,
-    bigInt: string,
-    bigIntPrimaryAutoIncrement: string,
-    float: string,
-    double: string,
-    numeric: (precision: number, scale: number) => string,
-    char: (length: number) => string,
-    varChar: (maxLength: number) => string,
-    tinyText: string,
-    text: string,
-    longText: string,
-    binary: (length: number) => string,
-    varBinary: (maxLength: number) => string,
-    tinyBlob: string,
-    blob: string,
-    longBlob: string,
-    timestamp: string,
-    dateTime: string,
-    date: string,
-    time: string,
-  },
-}
-
-export {
-  type Driver,
-}

package/db/NullConstraint.d.ts

@@ -1,2 +0,0 @@
-type NullConstraint = 'notNull' | 'null';
-export { type NullConstraint, };

package/db/NullConstraint.ts

@@ -1,5 +0,0 @@
-type NullConstraint = 'notNull' | 'null'
-
-export {
-  type NullConstraint,
-}

package/db/ReferentialAction.d.ts

@@ -1,2 +0,0 @@
-type ReferentialAction = 'cascade' | 'restrict' | 'setNull';
-export { type ReferentialAction, };

package/db/ReferentialAction.ts

@@ -1,5 +0,0 @@
-type ReferentialAction = 'cascade' | 'restrict' | 'setNull'
-
-export {
-  type ReferentialAction,
-}