apeframework 0.0.0-dev.2 → 0.0.0-dev.21

package/db/schema/builder/dataType.js

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

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

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

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

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

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