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

package/config/errors/ConfigFileReadError.ts

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

package/config/errors/ConfigParseError.d.ts

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

package/config/errors/ConfigParseError.js

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,11 @@
+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

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

package/config/errors/ConfigPropertyNameError.js

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

package/config/errors/ConfigPropertyNameError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class ConfigPropertyNameError extends BaseError {
+  public constructor(name: string) {
+    super(`invalid property name "${name}"`)
+  }
+}
+
+export {
+  ConfigPropertyNameError,
+}

package/config/getConfig.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from './Config';
+import type { Properties } from './Properties';
+import type { Args } from '../cli/Args';
+import type { Env } from '../env/Env';
+declare const getConfig: <Type extends Config>(params: {
+    properties: Properties<Type>;
+    file?: {
+        path: string;
+        required?: boolean;
+    };
+    env?: Env;
+    args?: Args;
+}) => Type;
+export { getConfig, };

package/config/getConfig.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const getPropertyEnvVar_1 = require("./getPropertyEnvVar");
+const parseProperty_1 = require("./parseProperty");
+const readFile_1 = require("./readFile");
+const validatePropertyName_1 = require("./validatePropertyName");
+const getConfig = (params) => {
+    const file = params.file
+        ? (0, readFile_1.readFile)(params.file.path, params.file.required)
+        : {};
+    const env = params.env ?? {};
+    const args = params.args ?? { positional: [], optional: {} };
+    const config = {};
+    for (const name in params.properties) {
+        (0, validatePropertyName_1.validatePropertyName)(name);
+        config[name] = (0, parseProperty_1.parseProperty)(name, params.properties[name].parser, params.properties[name].default, file[name], env[(0, getPropertyEnvVar_1.getPropertyEnvVar)(name)], args.optional[name]);
+    }
+    return config;
+};
+exports.getConfig = getConfig;

package/config/getConfig.ts

@@ -0,0 +1,47 @@
+import { getPropertyEnvVar } from './getPropertyEnvVar'
+import { parseProperty } from './parseProperty'
+import { readFile } from './readFile'
+import { validatePropertyName } from './validatePropertyName'
+import type { Config } from './Config'
+import type { Properties } from './Properties'
+import type { Args } from '../cli/Args'
+import type { Env } from '../env/Env'
+
+const getConfig = <Type extends Config>(params: {
+  properties: Properties<Type>,
+  file?: {
+    path: string,
+    required?: boolean,
+  },
+  env?: Env,
+  args?: Args,
+}): Type => {
+  const file = params.file
+    ? readFile(params.file.path, params.file.required)
+    : {}
+
+  const env: Env = params.env ?? {}
+
+  const args: Args = params.args ?? { positional: [], optional: {} }
+
+  const config: Config = {}
+
+  for (const name in params.properties) {
+    validatePropertyName(name)
+
+    config[name] = parseProperty(
+      name,
+      params.properties[name].parser,
+      params.properties[name].default,
+      file[name],
+      env[getPropertyEnvVar(name)],
+      args.optional[name],
+    )
+  }
+
+  return config as Type
+}
+
+export {
+  getConfig,
+}

package/config/getPropertyEnvVar.d.ts

@@ -0,0 +1,2 @@
+declare const getPropertyEnvVar: (name: string) => string;
+export { getPropertyEnvVar, };

package/config/getPropertyEnvVar.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyEnvVar = void 0;
+const capitalLetterRegex = /[A-Z]/gu;
+const capitalLetterReplacer = (letter) => {
+    return `_${letter}`;
+};
+const getPropertyEnvVar = (name) => {
+    return name
+        .replace(capitalLetterRegex, capitalLetterReplacer)
+        .toUpperCase();
+};
+exports.getPropertyEnvVar = getPropertyEnvVar;

package/config/getPropertyEnvVar.ts

@@ -0,0 +1,15 @@
+const capitalLetterRegex = /[A-Z]/gu
+
+const capitalLetterReplacer = (letter: string): string => {
+  return `_${letter}`
+}
+
+const getPropertyEnvVar = (name: string): string => {
+  return name
+    .replace(capitalLetterRegex, capitalLetterReplacer)
+    .toUpperCase()
+}
+
+export {
+  getPropertyEnvVar,
+}

package/config/parseProperty.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../parser/Parser';
+declare const parseProperty: <Type>(name: string, parser: Parser<Type>, defaultValue: any, fileValue: any, envValue: any, argsValue: any) => Type;
+export { parseProperty, };

package/config/parseProperty.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProperty = void 0;
+const ConfigParseError_1 = require("./errors/ConfigParseError");
+const parseProperty = (name, parser, defaultValue, fileValue, envValue, argsValue) => {
+    const sources = [
+        {
+            name: 'command line arguments',
+            value: argsValue,
+        },
+        {
+            name: 'environment variables',
+            value: envValue,
+        },
+        {
+            name: 'configuration file',
+            value: fileValue,
+        },
+        {
+            name: 'default value',
+            value: defaultValue,
+        },
+    ];
+    const source = sources.find((s) => {
+        return s.value !== undefined;
+    }) || {
+        name: 'undefined value',
+        value: undefined,
+    };
+    try {
+        return parser(source.value);
+    }
+    catch (error) {
+        throw new ConfigParseError_1.ConfigParseError(name, source.name, error.message);
+    }
+};
+exports.parseProperty = parseProperty;

package/config/parseProperty.ts

@@ -0,0 +1,47 @@
+import { ConfigParseError } from './errors/ConfigParseError'
+import type { Parser } from '../parser/Parser'
+
+const parseProperty = <Type>(
+  name: string,
+  parser: Parser<Type>,
+  defaultValue: any,
+  fileValue: any,
+  envValue: any,
+  argsValue: any,
+): Type => {
+  const sources = [
+    {
+      name: 'command line arguments',
+      value: argsValue,
+    },
+    {
+      name: 'environment variables',
+      value: envValue,
+    },
+    {
+      name: 'configuration file',
+      value: fileValue,
+    },
+    {
+      name: 'default value',
+      value: defaultValue,
+    },
+  ]
+
+  const source = sources.find((s) => {
+    return s.value !== undefined
+  }) || {
+    name: 'undefined value',
+    value: undefined,
+  }
+
+  try {
+    return parser(source.value)
+  } catch (error) {
+    throw new ConfigParseError(name, source.name, (error as Error).message)
+  }
+}
+
+export {
+  parseProperty,
+}

package/config/readFile.d.ts

@@ -0,0 +1,2 @@
+declare const readFile: (path: string, required?: boolean) => Record<string, any>;
+export { readFile, };

package/config/readFile.js

@@ -0,0 +1,31 @@
+"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 fs_extra_1 = __importDefault(require("fs-extra"));
+const ConfigFileReadError_1 = require("./errors/ConfigFileReadError");
+const readFile = (path, required = false) => {
+    let json = {};
+    let fileExists;
+    try {
+        fileExists = fs_extra_1.default.existsSync(path);
+        if (fileExists) {
+            json = fs_extra_1.default.readJsonSync(path);
+        }
+    }
+    catch (error) {
+        throw new ConfigFileReadError_1.ConfigFileReadError(path, error.message);
+    }
+    if (required && !fileExists) {
+        throw new ConfigFileReadError_1.ConfigFileReadError(path, 'missing file');
+    }
+    if (typeof json !== 'object'
+        || Array.isArray(json)
+        || json === null) {
+        throw new ConfigFileReadError_1.ConfigFileReadError(path, 'invalid content');
+    }
+    return json;
+};
+exports.readFile = readFile;

package/config/readFile.ts

@@ -0,0 +1,34 @@
+import fs from 'fs-extra'
+import { ConfigFileReadError } from './errors/ConfigFileReadError'
+
+const readFile = (path: string, required = false): Record<string, any> => {
+  let json: any = {}
+  let fileExists: boolean
+
+  try {
+    fileExists = fs.existsSync(path)
+    if (fileExists) {
+      json = fs.readJsonSync(path)
+    }
+  } catch (error) {
+    throw new ConfigFileReadError(path, (error as Error).message)
+  }
+
+  if (required && !fileExists) {
+    throw new ConfigFileReadError(path, 'missing file')
+  }
+
+  if (
+    typeof json !== 'object'
+    || Array.isArray(json)
+    || json === null
+  ) {
+    throw new ConfigFileReadError(path, 'invalid content')
+  }
+
+  return json as Record<string, any>
+}
+
+export {
+  readFile,
+}

package/config/validatePropertyName.d.ts

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

package/config/validatePropertyName.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePropertyName = void 0;
+const ConfigPropertyNameError_1 = require("./errors/ConfigPropertyNameError");
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u;
+const validatePropertyName = (name) => {
+    if (!propertyNameRegex.test(name)) {
+        throw new ConfigPropertyNameError_1.ConfigPropertyNameError(name);
+    }
+};
+exports.validatePropertyName = validatePropertyName;

package/config/validatePropertyName.ts

@@ -0,0 +1,13 @@
+import { ConfigPropertyNameError } from './errors/ConfigPropertyNameError'
+
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u
+
+const validatePropertyName = (name: string): void => {
+  if (!propertyNameRegex.test(name)) {
+    throw new ConfigPropertyNameError(name)
+  }
+}
+
+export {
+  validatePropertyName,
+}

package/db/ColumnBuilder.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,42 @@
+"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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,49 @@
+"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

@@ -0,0 +1,74 @@
+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,
+}