apeframework 0.0.0-dev.2 → 0.0.0-dev.3

package/db/TableBuilder.ts

@@ -0,0 +1,367 @@
+import { ColumnBuilder } from './ColumnBuilder'
+import { getConstraintName } from './getConstraintName'
+import { getReferentialActionSql } from './getReferentialActionSql'
+import { setNullConstraint } from './setNullConstraint'
+import { validateColumnLength } from './validateColumnLength'
+import { validateColumnMaxLength } from './validateColumnMaxLength'
+import { validateColumnPrecision } from './validateColumnPrecision'
+import type { Driver } from './Driver'
+import type { NullConstraint } from './NullConstraint'
+import type { ReferentialAction } from './ReferentialAction'
+import type { Knex } from 'knex'
+
+class TableBuilder {
+  private readonly table: string
+
+  private readonly knexTableBuilder: Knex.TableBuilder
+
+  private readonly driver: Driver
+
+  public constructor(
+    table: string,
+    knexTableBuilder: Knex.TableBuilder,
+    driver: Driver,
+  ) {
+    this.table = table
+    this.knexTableBuilder = knexTableBuilder
+    this.driver = driver
+  }
+
+  public boolean(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.boolean)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public tinyInt(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.tinyInt)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public smallInt(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.smallInt)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public smallIntPrimaryAutoIncrement(
+    column: string,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.smallIntPrimaryAutoIncrement)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public int(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.int)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public intPrimaryAutoIncrement(
+    column: string,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.intPrimaryAutoIncrement)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public bigInt(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.bigInt)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public bigIntPrimaryAutoIncrement(
+    column: string,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.bigIntPrimaryAutoIncrement)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public float(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.float)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public double(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.double)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public numeric(
+    column: string,
+    precision: number,
+    scale: number,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    validateColumnPrecision(precision, scale)
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.numeric(precision, scale))
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public char(
+    column: string,
+    length: number,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    validateColumnLength(length)
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.char(length))
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public varChar(
+    column: string,
+    maxLength: number,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    validateColumnMaxLength(maxLength)
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.varChar(maxLength))
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public tinyText(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.tinyText)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public text(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.text)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public longText(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.longText)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public binary(
+    column: string,
+    length: number,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    validateColumnLength(length)
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.binary(length))
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public varBinary(
+    column: string,
+    maxLength: number,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    validateColumnMaxLength(maxLength)
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.varBinary(maxLength))
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public tinyBlob(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.tinyBlob)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public blob(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.blob)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public longBlob(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.longBlob)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public timestamp(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.timestamp)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public dateTime(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.dateTime)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public date(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.date)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public time(
+    column: string,
+    nullConstraint: NullConstraint,
+  ): ColumnBuilder {
+    const knexColumnBuilder = this.knexTableBuilder
+      .specificType(column, this.driver.dataType.time)
+    setNullConstraint(knexColumnBuilder, nullConstraint)
+    return new ColumnBuilder(this.table, column, knexColumnBuilder)
+  }
+
+  public dropColumn(column: string): this {
+    this.knexTableBuilder.dropColumn(column)
+    return this
+  }
+
+  public renameColumn(column: string, newName: string): this {
+    this.knexTableBuilder.renameColumn(column, newName)
+    return this
+  }
+
+  public setNull(column: string): this {
+    this.knexTableBuilder.setNullable(column)
+    return this
+  }
+
+  public setNotNull(column: string): this {
+    this.knexTableBuilder.dropNullable(column)
+    return this
+  }
+
+  public setPrimary(columns: string[]): this {
+    this.knexTableBuilder.primary(columns, {
+      constraintName: 'PRIMARY',
+    })
+    return this
+  }
+
+  public dropPrimary(): this {
+    this.knexTableBuilder.dropPrimary('PRIMARY')
+    return this
+  }
+
+  public addForeign(
+    columns: string[],
+    referencedTable: string,
+    referencedColumns: string[],
+    onUpdate: ReferentialAction,
+    onDelete: ReferentialAction,
+  ): this {
+    this.knexTableBuilder
+      .foreign(columns, getConstraintName('FOREIGN', this.table, columns))
+      .references(referencedColumns)
+      .inTable(referencedTable)
+      .onUpdate(getReferentialActionSql(onUpdate))
+      .onDelete(getReferentialActionSql(onDelete))
+    return this
+  }
+
+  public dropForeign(columns: string[]): this {
+    this.knexTableBuilder
+      .dropForeign(columns, getConstraintName('FOREIGN', this.table, columns))
+    return this
+  }
+
+  public addIndex(columns: string[]): this {
+    this.knexTableBuilder
+      .index(columns, getConstraintName('INDEX', this.table, columns))
+    return this
+  }
+
+  public dropIndex(columns: string[]): this {
+    this.knexTableBuilder
+      .dropIndex(columns, getConstraintName('INDEX', this.table, columns))
+    return this
+  }
+
+  public addUnique(columns: string[]): this {
+    this.knexTableBuilder.unique(columns, {
+      indexName: getConstraintName('UNIQUE', this.table, columns),
+    })
+    return this
+  }
+
+  public dropUnique(columns: string[]): this {
+    this.knexTableBuilder
+      .dropUnique(columns, getConstraintName('UNIQUE', this.table, columns))
+    return this
+  }
+}
+
+export {
+  TableBuilder,
+}

package/db/adapters/mysql/createMysqlDatabase.d.ts

@@ -0,0 +1,12 @@
+import { Database } from '../../Database';
+import type { Tls } from '../../../tls/Tls';
+declare const createMysqlDatabase: (params: {
+    host: string;
+    port: number;
+    tls?: Tls;
+    user: string;
+    password?: string;
+    database: string;
+    maxConnections?: number;
+}) => Database;
+export { createMysqlDatabase, };

package/db/adapters/mysql/createMysqlDatabase.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMysqlDatabase = void 0;
+const knex_1 = __importDefault(require("knex"));
+const getTls_1 = require("../../../tls/getTls");
+const Database_1 = require("../../Database");
+const driver_1 = require("./driver");
+const typeCast_1 = require("./typeCast");
+const createMysqlDatabase = (params) => {
+    return new Database_1.Database((0, knex_1.default)({
+        client: 'mysql2',
+        connection: {
+            host: params.host,
+            port: params.port,
+            ssl: (0, getTls_1.getTls)(params.tls),
+            user: params.user,
+            password: params.password,
+            database: params.database,
+            dateStrings: true,
+            typeCast: typeCast_1.typeCast,
+        },
+        pool: {
+            min: 0,
+            max: params.maxConnections,
+        },
+        useNullAsDefault: true,
+    }), driver_1.driver);
+};
+exports.createMysqlDatabase = createMysqlDatabase;

package/db/adapters/mysql/createMysqlDatabase.ts

@@ -0,0 +1,39 @@
+import knex from 'knex'
+import { getTls } from '../../../tls/getTls'
+import { Database } from '../../Database'
+import { driver } from './driver'
+import { typeCast } from './typeCast'
+import type { Tls } from '../../../tls/Tls'
+
+const createMysqlDatabase = (params: {
+  host: string,
+  port: number,
+  tls?: Tls,
+  user: string,
+  password?: string,
+  database: string,
+  maxConnections?: number,
+}): Database => {
+  return new Database(knex({
+    client: 'mysql2',
+    connection: {
+      host: params.host,
+      port: params.port,
+      ssl: getTls(params.tls),
+      user: params.user,
+      password: params.password,
+      database: params.database,
+      dateStrings: true,
+      typeCast,
+    },
+    pool: {
+      min: 0,
+      max: params.maxConnections,
+    },
+    useNullAsDefault: true,
+  }), driver)
+}
+
+export {
+  createMysqlDatabase,
+}

package/db/adapters/mysql/driver.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '../../Driver';
+declare const driver: Driver;
+export { driver, };

package/db/adapters/mysql/driver.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driver = void 0;
+const driver = {
+    dataType: {
+        boolean: 'BIT',
+        tinyInt: 'TINYINT',
+        smallInt: 'SMALLINT',
+        smallIntPrimaryAutoIncrement: 'SMALLINT PRIMARY KEY AUTO_INCREMENT',
+        int: 'INTEGER',
+        intPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTO_INCREMENT',
+        bigInt: 'BIGINT',
+        bigIntPrimaryAutoIncrement: 'BIGINT PRIMARY KEY AUTO_INCREMENT',
+        float: 'FLOAT',
+        double: 'DOUBLE',
+        numeric: (precision, scale) => {
+            return `NUMERIC(${precision}, ${scale})`;
+        },
+        char: (length) => {
+            return `CHAR(${length})`;
+        },
+        varChar: (maxLength) => {
+            return `VARCHAR(${maxLength})`;
+        },
+        tinyText: 'TINYTEXT',
+        text: 'TEXT',
+        longText: 'LONGTEXT',
+        binary: (length) => {
+            return `BINARY(${length})`;
+        },
+        varBinary: (maxLength) => {
+            return `VARBINARY(${maxLength})`;
+        },
+        tinyBlob: 'TINYBLOB',
+        blob: 'BLOB',
+        longBlob: 'LONGBLOB',
+        timestamp: 'TIMESTAMP(3)',
+        dateTime: 'DATETIME(3)',
+        date: 'DATE',
+        time: 'TIME(3)',
+    },
+};
+exports.driver = driver;

package/db/adapters/mysql/driver.ts

@@ -0,0 +1,45 @@
+import type { Driver } from '../../Driver'
+
+const driver: Driver = {
+  dataType: {
+    boolean: 'BIT',
+    tinyInt: 'TINYINT',
+    smallInt: 'SMALLINT',
+    smallIntPrimaryAutoIncrement: 'SMALLINT PRIMARY KEY AUTO_INCREMENT',
+    int: 'INTEGER',
+    intPrimaryAutoIncrement: 'INTEGER PRIMARY KEY AUTO_INCREMENT',
+    bigInt: 'BIGINT',
+    bigIntPrimaryAutoIncrement: 'BIGINT PRIMARY KEY AUTO_INCREMENT',
+    float: 'FLOAT',
+    double: 'DOUBLE',
+    numeric: (precision: number, scale: number) => {
+      return `NUMERIC(${precision}, ${scale})`
+    },
+    char: (length: number) => {
+      return `CHAR(${length})`
+    },
+    varChar: (maxLength: number) => {
+      return `VARCHAR(${maxLength})`
+    },
+    tinyText: 'TINYTEXT',
+    text: 'TEXT',
+    longText: 'LONGTEXT',
+    binary: (length: number) => {
+      return `BINARY(${length})`
+    },
+    varBinary: (maxLength: number) => {
+      return `VARBINARY(${maxLength})`
+    },
+    tinyBlob: 'TINYBLOB',
+    blob: 'BLOB',
+    longBlob: 'LONGBLOB',
+    timestamp: 'TIMESTAMP(3)',
+    dateTime: 'DATETIME(3)',
+    date: 'DATE',
+    time: 'TIME(3)',
+  },
+}
+
+export {
+  driver,
+}

package/db/adapters/mysql/typeCast.d.ts

@@ -0,0 +1,2 @@
+declare const typeCast: (field: any, next: any) => any;
+export { typeCast, };

package/db/adapters/mysql/typeCast.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeCast = void 0;
+let value;
+const typeCast = (field, next) => {
+    switch (field.type) {
+        case 'BIT':
+            value = field.buffer();
+            return value === null ? null : Boolean(value[0]);
+        case 'NEWDECIMAL':
+            value = field.string();
+            return value === null ? null : parseFloat(value);
+        default:
+            return next();
+    }
+};
+exports.typeCast = typeCast;

package/db/adapters/mysql/typeCast.ts

@@ -0,0 +1,18 @@
+let value: any
+
+const typeCast = (field: any, next: any): any => {
+  switch (field.type) {
+    case 'BIT':
+      value = field.buffer()
+      return value === null ? null : Boolean(value[0])
+    case 'NEWDECIMAL':
+      value = field.string()
+      return value === null ? null : parseFloat(value)
+    default:
+      return next()
+  }
+}
+
+export {
+  typeCast,
+}

package/db/adapters/postgres/driver.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '../../Driver';
+declare const driver: Driver;
+export { driver, };

package/db/adapters/postgres/driver.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driver = void 0;
+const driver = {
+    dataType: {
+        boolean: 'BOOLEAN',
+        tinyInt: 'SMALLINT',
+        smallInt: 'SMALLINT',
+        smallIntPrimaryAutoIncrement: 'SMALLSERIAL PRIMARY KEY',
+        int: 'INTEGER',
+        intPrimaryAutoIncrement: 'SERIAL PRIMARY KEY',
+        bigInt: 'BIGINT',
+        bigIntPrimaryAutoIncrement: 'BIGSERIAL PRIMARY KEY',
+        float: 'REAL',
+        double: 'DOUBLE PRECISION',
+        numeric: (precision, scale) => {
+            return `NUMERIC(${precision}, ${scale})`;
+        },
+        char: (length) => {
+            return `CHAR(${length})`;
+        },
+        varChar: (maxLength) => {
+            return `VARCHAR(${maxLength})`;
+        },
+        tinyText: 'TEXT',
+        text: 'TEXT',
+        longText: 'TEXT',
+        binary: () => {
+            return 'BYTEA';
+        },
+        varBinary: () => {
+            return 'BYTEA';
+        },
+        tinyBlob: 'BYTEA',
+        blob: 'BYTEA',
+        longBlob: 'BYTEA',
+        timestamp: 'TIMESTAMP(3)',
+        dateTime: 'TIMESTAMP(3)',
+        date: 'DATE',
+        time: 'TIME(3)',
+    },
+};
+exports.driver = driver;

package/db/adapters/postgres/driver.ts

@@ -0,0 +1,45 @@
+import type { Driver } from '../../Driver'
+
+const driver: Driver = {
+  dataType: {
+    boolean: 'BOOLEAN',
+    tinyInt: 'SMALLINT',
+    smallInt: 'SMALLINT',
+    smallIntPrimaryAutoIncrement: 'SMALLSERIAL PRIMARY KEY',
+    int: 'INTEGER',
+    intPrimaryAutoIncrement: 'SERIAL PRIMARY KEY',
+    bigInt: 'BIGINT',
+    bigIntPrimaryAutoIncrement: 'BIGSERIAL PRIMARY KEY',
+    float: 'REAL',
+    double: 'DOUBLE PRECISION',
+    numeric: (precision: number, scale: number) => {
+      return `NUMERIC(${precision}, ${scale})`
+    },
+    char: (length: number) => {
+      return `CHAR(${length})`
+    },
+    varChar: (maxLength: number) => {
+      return `VARCHAR(${maxLength})`
+    },
+    tinyText: 'TEXT',
+    text: 'TEXT',
+    longText: 'TEXT',
+    binary: () => {
+      return 'BYTEA'
+    },
+    varBinary: () => {
+      return 'BYTEA'
+    },
+    tinyBlob: 'BYTEA',
+    blob: 'BYTEA',
+    longBlob: 'BYTEA',
+    timestamp: 'TIMESTAMP(3)',
+    dateTime: 'TIMESTAMP(3)',
+    date: 'DATE',
+    time: 'TIME(3)',
+  },
+}
+
+export {
+  driver,
+}

package/db/adapters/sqlite/driver.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '../../Driver';
+declare const driver: Driver;
+export { driver, };