apeframework 0.0.0-dev.1

package/db/schema/builder/dataType.js

@@ -0,0 +1,170 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../../config");
+var dataType = function (types) {
+    var dataTypes = __assign(__assign({}, types), { memory: types.sqlite });
+    return dataTypes[config_1.module];
+};
+var boolean = function () { return dataType({
+    mysql: 'bit',
+    postgres: 'boolean',
+    sqlite: 'integer',
+}); };
+var tinyInt = function () { return dataType({
+    mysql: 'tinyint',
+    postgres: 'smallint',
+    sqlite: 'integer',
+}); };
+var smallInt = function () { return dataType({
+    mysql: 'smallint',
+    postgres: 'smallint',
+    sqlite: 'integer',
+}); };
+var smallIntPrimaryAutoIncrement = function () { return dataType({
+    mysql: 'smallint primary key auto_increment',
+    postgres: 'smallserial primary key',
+    sqlite: 'integer primary key autoincrement',
+}); };
+var int = function () { return dataType({
+    mysql: 'integer',
+    postgres: 'integer',
+    sqlite: 'integer',
+}); };
+var intPrimaryAutoIncrement = function () { return dataType({
+    mysql: 'integer primary key auto_increment',
+    postgres: 'serial primary key',
+    sqlite: 'integer primary key autoincrement',
+}); };
+var bigInt = function () { return dataType({
+    mysql: 'bigint',
+    postgres: 'bigint',
+    sqlite: 'integer',
+}); };
+var bigIntPrimaryAutoIncrement = function () { return dataType({
+    mysql: 'bigint primary key auto_increment',
+    postgres: 'bigserial primary key',
+    sqlite: 'integer primary key autoincrement',
+}); };
+var float = function () { return dataType({
+    mysql: 'float',
+    postgres: 'real',
+    sqlite: 'real',
+}); };
+var double = function () { return dataType({
+    mysql: 'double',
+    postgres: 'double precision',
+    sqlite: 'real',
+}); };
+var numeric = function (precision, scale) { return dataType({
+    mysql: "numeric(".concat(precision, ", ").concat(scale, ")"),
+    postgres: "numeric(".concat(precision, ", ").concat(scale, ")"),
+    sqlite: 'numeric',
+}); };
+var char = function (length) { return dataType({
+    mysql: "char(".concat(length, ")"),
+    postgres: "char(".concat(length, ")"),
+    sqlite: 'text',
+}); };
+var varChar = function (maxLength) { return dataType({
+    mysql: "varchar(".concat(maxLength, ")"),
+    postgres: "varchar(".concat(maxLength, ")"),
+    sqlite: 'text',
+}); };
+var tinyText = function () { return dataType({
+    mysql: 'tinytext',
+    postgres: 'text',
+    sqlite: 'text',
+}); };
+var text = function () { return dataType({
+    mysql: 'text',
+    postgres: 'text',
+    sqlite: 'text',
+}); };
+var longText = function () { return dataType({
+    mysql: 'longtext',
+    postgres: 'text',
+    sqlite: 'text',
+}); };
+var binary = function (length) { return dataType({
+    mysql: "binary(".concat(length, ")"),
+    postgres: 'bytea',
+    sqlite: 'blob',
+}); };
+var varBinary = function (maxLength) { return dataType({
+    mysql: "varbinary(".concat(maxLength, ")"),
+    postgres: 'bytea',
+    sqlite: 'blob',
+}); };
+var tinyBlob = function () { return dataType({
+    mysql: 'tinyblob',
+    postgres: 'bytea',
+    sqlite: 'blob',
+}); };
+var blob = function () { return dataType({
+    mysql: 'blob',
+    postgres: 'bytea',
+    sqlite: 'blob',
+}); };
+var longBlob = function () { return dataType({
+    mysql: 'longblob',
+    postgres: 'bytea',
+    sqlite: 'blob',
+}); };
+var timestamp = function () { return dataType({
+    mysql: 'timestamp(3)',
+    postgres: 'timestamp(3)',
+    sqlite: 'text',
+}); };
+var dateTime = function () { return dataType({
+    mysql: ' datetime(3)',
+    postgres: 'timestamp(3)',
+    sqlite: 'text',
+}); };
+var date = function () { return dataType({
+    mysql: 'date',
+    postgres: 'date',
+    sqlite: 'text',
+}); };
+var time = function () { return dataType({
+    mysql: 'time(3)',
+    postgres: 'time(3)',
+    sqlite: 'text',
+}); };
+exports.default = {
+    bigInt: bigInt,
+    bigIntPrimaryAutoIncrement: bigIntPrimaryAutoIncrement,
+    binary: binary,
+    blob: blob,
+    boolean: boolean,
+    char: char,
+    date: date,
+    dateTime: dateTime,
+    double: double,
+    float: float,
+    int: int,
+    intPrimaryAutoIncrement: intPrimaryAutoIncrement,
+    longBlob: longBlob,
+    longText: longText,
+    numeric: numeric,
+    smallInt: smallInt,
+    smallIntPrimaryAutoIncrement: smallIntPrimaryAutoIncrement,
+    text: text,
+    time: time,
+    timestamp: timestamp,
+    tinyBlob: tinyBlob,
+    tinyInt: tinyInt,
+    tinyText: tinyText,
+    varBinary: varBinary,
+    varChar: varChar,
+};

package/db/schema/builder/dataType.ts

@@ -0,0 +1,184 @@
+import { module, Module } from '../../config'
+
+const dataType = (types: { [module in Exclude<Module, 'memory'>]: string }) => {
+  const dataTypes: { [module in Module]: string } = { ...types, memory: types.sqlite }
+  return dataTypes[module]
+}
+
+const boolean = () => dataType({
+  mysql: 'bit',
+  postgres: 'boolean',
+  sqlite: 'integer',
+})
+
+const tinyInt = () => dataType({
+  mysql: 'tinyint',
+  postgres: 'smallint',
+  sqlite: 'integer',
+})
+
+const smallInt = () => dataType({
+  mysql: 'smallint',
+  postgres: 'smallint',
+  sqlite: 'integer',
+})
+
+const smallIntPrimaryAutoIncrement = () => dataType({
+  mysql: 'smallint primary key auto_increment',
+  postgres: 'smallserial primary key',
+  sqlite: 'integer primary key autoincrement',
+})
+
+const int = () => dataType({
+  mysql: 'integer',
+  postgres: 'integer',
+  sqlite: 'integer',
+})
+
+const intPrimaryAutoIncrement = () => dataType({
+  mysql: 'integer primary key auto_increment',
+  postgres: 'serial primary key',
+  sqlite: 'integer primary key autoincrement',
+})
+
+const bigInt = () => dataType({
+  mysql: 'bigint',
+  postgres: 'bigint',
+  sqlite: 'integer',
+})
+
+const bigIntPrimaryAutoIncrement = () => dataType({
+  mysql: 'bigint primary key auto_increment',
+  postgres: 'bigserial primary key',
+  sqlite: 'integer primary key autoincrement',
+})
+
+const float = () => dataType({
+  mysql: 'float',
+  postgres: 'real',
+  sqlite: 'real',
+})
+
+const double = () => dataType({
+  mysql: 'double',
+  postgres: 'double precision',
+  sqlite: 'real',
+})
+
+const numeric = (precision: number, scale: number) => dataType({
+  mysql: `numeric(${precision}, ${scale})`,
+  postgres: `numeric(${precision}, ${scale})`,
+  sqlite: 'numeric',
+})
+
+const char = (length: number) => dataType({
+  mysql: `char(${length})`,
+  postgres: `char(${length})`,
+  sqlite: 'text',
+})
+
+const varChar = (maxLength: number) => dataType({
+  mysql: `varchar(${maxLength})`,
+  postgres: `varchar(${maxLength})`,
+  sqlite: 'text',
+})
+
+const tinyText = () => dataType({
+  mysql: 'tinytext',
+  postgres: 'text',
+  sqlite: 'text',
+})
+
+const text = () => dataType({
+  mysql: 'text',
+  postgres: 'text',
+  sqlite: 'text',
+})
+
+const longText = () => dataType({
+  mysql: 'longtext',
+  postgres: 'text',
+  sqlite: 'text',
+})
+
+const binary = (length: number) => dataType({
+  mysql: `binary(${length})`,
+  postgres: 'bytea',
+  sqlite: 'blob',
+})
+
+const varBinary = (maxLength: number) => dataType({
+  mysql: `varbinary(${maxLength})`,
+  postgres: 'bytea',
+  sqlite: 'blob',
+})
+
+const tinyBlob = () => dataType({
+  mysql: 'tinyblob',
+  postgres: 'bytea',
+  sqlite: 'blob',
+})
+
+const blob = () => dataType({
+  mysql: 'blob',
+  postgres: 'bytea',
+  sqlite: 'blob',
+})
+
+const longBlob = () => dataType({
+  mysql: 'longblob',
+  postgres: 'bytea',
+  sqlite: 'blob',
+})
+
+const timestamp = () => dataType({
+  mysql: 'timestamp(3)',
+  postgres: 'timestamp(3)',
+  sqlite: 'text',
+})
+
+const dateTime = () => dataType({
+  mysql: ' datetime(3)',
+  postgres: 'timestamp(3)',
+  sqlite: 'text',
+})
+
+const date = () => dataType({
+  mysql: 'date',
+  postgres: 'date',
+  sqlite: 'text',
+})
+
+const time = () => dataType({
+  mysql: 'time(3)',
+  postgres: 'time(3)',
+  sqlite: 'text',
+})
+
+export default {
+  bigInt,
+  bigIntPrimaryAutoIncrement,
+  binary,
+  blob,
+  boolean,
+  char,
+  date,
+  dateTime,
+  double,
+  float,
+  int,
+  intPrimaryAutoIncrement,
+  longBlob,
+  longText,
+  numeric,
+  smallInt,
+  smallIntPrimaryAutoIncrement,
+  text,
+  time,
+  timestamp,
+  tinyBlob,
+  tinyInt,
+  tinyText,
+  varBinary,
+  varChar,
+}

package/db/schema/builder/index.d.ts

@@ -0,0 +1,15 @@
+import { TableBuilder } from './tableBuilder';
+import type { Database } from '../../database';
+export declare class SchemaBuilder {
+    private db;
+    constructor(db: Database);
+    createTable(name: string, build: (table: TableBuilder) => void): Database.SchemaBuilder;
+    createTableLike(name: string, likeName: string, build: (table: TableBuilder) => void): Database.SchemaBuilder;
+    alterTable(name: string, build: (table: TableBuilder) => void): Database.SchemaBuilder;
+    dropTable(name: string): Database.SchemaBuilder;
+    dropTableIfExists(name: string): Database.SchemaBuilder;
+    renameTable(name: string, toName: string): Promise<void>;
+    hasTable(name: string): Promise<boolean>;
+    hasColumn(tableName: string, columnName: string): Promise<boolean>;
+}
+export default SchemaBuilder;

package/db/schema/builder/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaBuilder = void 0;
+var tableBuilder_1 = require("./tableBuilder");
+var SchemaBuilder = /** @class */ (function () {
+    function SchemaBuilder(db) {
+        this.db = db;
+    }
+    SchemaBuilder.prototype.createTable = function (name, build) {
+        return this.db.schema.createTable(name, function (knexTableBuilder) {
+            build(new tableBuilder_1.TableBuilder(knexTableBuilder));
+        });
+    };
+    SchemaBuilder.prototype.createTableLike = function (name, likeName, build) {
+        return this.db.schema.createTableLike(name, likeName, function (knexTableBuilder) {
+            build(new tableBuilder_1.TableBuilder(knexTableBuilder));
+        });
+    };
+    SchemaBuilder.prototype.alterTable = function (name, build) {
+        return this.db.schema.alterTable(name, function (knexTableBuilder) {
+            build(new tableBuilder_1.TableBuilder(knexTableBuilder));
+        });
+    };
+    SchemaBuilder.prototype.dropTable = function (name) {
+        return this.db.schema.dropTable(name);
+    };
+    SchemaBuilder.prototype.dropTableIfExists = function (name) {
+        return this.db.schema.dropTableIfExists(name);
+    };
+    SchemaBuilder.prototype.renameTable = function (name, toName) {
+        return this.db.schema.renameTable(name, toName);
+    };
+    SchemaBuilder.prototype.hasTable = function (name) {
+        return this.db.schema.hasTable(name);
+    };
+    SchemaBuilder.prototype.hasColumn = function (tableName, columnName) {
+        return this.db.schema.hasColumn(tableName, columnName);
+    };
+    return SchemaBuilder;
+}());
+exports.SchemaBuilder = SchemaBuilder;
+exports.default = SchemaBuilder;

package/db/schema/builder/index.ts

@@ -0,0 +1,50 @@
+import { TableBuilder } from './tableBuilder'
+import type { Database } from '../../database'
+
+export class SchemaBuilder {
+  private db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  createTable(name: string, build: (table: TableBuilder) => void) {
+    return this.db.schema.createTable(name, (knexTableBuilder) => {
+      build(new TableBuilder(knexTableBuilder))
+    })
+  }
+
+  createTableLike(name: string, likeName: string, build: (table: TableBuilder) => void) {
+    return this.db.schema.createTableLike(name, likeName, (knexTableBuilder) => {
+      build(new TableBuilder(knexTableBuilder))
+    })
+  }
+
+  alterTable(name: string, build: (table: TableBuilder) => void) {
+    return this.db.schema.alterTable(name, (knexTableBuilder) => {
+      build(new TableBuilder(knexTableBuilder))
+    })
+  }
+
+  dropTable(name: string) {
+    return this.db.schema.dropTable(name)
+  }
+
+  dropTableIfExists(name: string) {
+    return this.db.schema.dropTableIfExists(name)
+  }
+
+  renameTable(name: string, toName: string) {
+    return this.db.schema.renameTable(name, toName)
+  }
+
+  hasTable(name: string) {
+    return this.db.schema.hasTable(name)
+  }
+
+  hasColumn(tableName: string, columnName: string) {
+    return this.db.schema.hasColumn(tableName, columnName)
+  }
+}
+
+export default SchemaBuilder

package/db/schema/builder/tableBuilder.d.ts

@@ -0,0 +1,45 @@
+import { ColumnBuilder } from './columnBuilder';
+import type { Database } from '../../database';
+export type NullConstraint = 'null' | 'notNull';
+export declare class TableBuilder {
+    private knexTableBuilder;
+    constructor(knexTableBuilder: Database.TableBuilder);
+    boolean(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    tinyInt(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    smallInt(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    smallIntPrimaryAutoIncrement(name: string): ColumnBuilder;
+    int(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    intPrimaryAutoIncrement(name: string): ColumnBuilder;
+    bigInt(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    bigIntPrimaryAutoIncrement(name: string): ColumnBuilder;
+    float(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    double(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    numeric(name: string, precision: number, scale: number, nullConstraint: NullConstraint): ColumnBuilder;
+    char(name: string, length: number, nullConstraint: NullConstraint): ColumnBuilder;
+    varChar(name: string, maxLength: number, nullConstraint: NullConstraint): ColumnBuilder;
+    tinyText(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    text(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    longText(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    binary(name: string, length: number, nullConstraint: NullConstraint): ColumnBuilder;
+    varBinary(name: string, maxLength: number, nullConstraint: NullConstraint): ColumnBuilder;
+    tinyBlob(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    blob(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    longBlob(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    timestamp(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    dateTime(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    date(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    time(name: string, nullConstraint: NullConstraint): ColumnBuilder;
+    dropColumn(name: string): this;
+    renameColumn(name: string, toName: string): this;
+    setNull(): void;
+    setNotNull(): void;
+    setPrimary(): void;
+    dropPrimary(): void;
+    addForeign(): void;
+    dropForeign(): void;
+    addUnique(): void;
+    dropUnique(): void;
+    addIndex(): void;
+    dropIndex(): void;
+}
+export default TableBuilder;