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

package/db/postProcess.ts

@@ -1,27 +0,0 @@
-export const booleanColumnRegex = /^((is|has)(_|[A-Z]))/
-
-const booleanColumns = (columns: string[]) => columns.filter(
-  (column) => column.match(booleanColumnRegex),
-)
-
-const postProcessRow = (row: any, boolColumns: string[]) => {
-  boolColumns.forEach((column) => {
-    row[column] = row[column] === null ? null : !!row[column]
-  })
-  return row
-}
-
-const postProcess = (response: any) => {
-  if (Array.isArray(response) && typeof response[0] === 'object') {
-    for (const row of response) {
-      postProcessRow(row, booleanColumns(Object.keys(response[0])))
-    }
-    return response
-  }
-  if (typeof response === 'object') {
-    return postProcessRow(response, booleanColumns(Object.keys(response)))
-  }
-  return response
-}
-
-export default postProcess

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

@@ -1,30 +0,0 @@
-import type { Database } from '../../database';
-export interface Table {
-    db: Database;
-    name: string;
-}
-export interface Column {
-    name: string;
-    dataType: DataType;
-    nullConstraint: NullConstraint;
-    index?: Index;
-    referencedTable?: string;
-    onDelete?: OnDelete;
-}
-export type DataType = 'boolean' | 'decimal' | 'integer' | 'string';
-export type NullConstraint = 'notNull' | 'null';
-export type Index = 'index' | 'noIndex' | 'primary' | 'unique';
-export type OnDelete = 'cascade' | 'restrict';
-export declare const shortName: (...name: string[]) => string;
-export declare const createTable: (table: Table, ...columns: Column[]) => Database.SchemaBuilder;
-export declare const dropTable: (table: Table) => Database.SchemaBuilder;
-export declare const table: (db: Database, name: string) => Table;
-export declare const column: (name: string, dataType: DataType, nullConstraint: NullConstraint, index?: Index, referencedTable?: string, onDelete?: OnDelete) => Column;
-declare const _default: {
-    column: (name: string, dataType: DataType, nullConstraint: NullConstraint, index?: Index | undefined, referencedTable?: string | undefined, onDelete?: OnDelete | undefined) => Column;
-    createTable: (table: Table, ...columns: Column[]) => Database.SchemaBuilder;
-    dropTable: (table: Table) => Database.SchemaBuilder;
-    shortName: (...name: string[]) => string;
-    table: (db: Database<any, any[]>, name: string) => Table;
-};
-export default _default;

package/db/schema/builder/_.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.column = exports.table = exports.dropTable = exports.createTable = exports.shortName = void 0;
-var longNameRegex = /[A-Z][a-z]{4,}|[a-z]{5,}/g;
-var shortName = function () {
-    var name = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        name[_i] = arguments[_i];
-    }
-    return name
-        .map(function (string) { return string.replace(longNameRegex, function (match) { return match.substring(0, 4); }); })
-        .join('_');
-};
-exports.shortName = shortName;
-var createTable = function (table) {
-    var columns = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        columns[_i - 1] = arguments[_i];
-    }
-    return table.db.schema
-        .createTable(table.name, function (tableBuilder) {
-        var primaryKey = [];
-        columns.forEach(function (column) {
-            var columnBuilder;
-            switch (column.dataType) {
-                case 'boolean':
-                    columnBuilder = tableBuilder.boolean(column.name);
-                    break;
-                case 'decimal':
-                    columnBuilder = tableBuilder.decimal(column.name, 32, 16);
-                    break;
-                case 'integer':
-                    columnBuilder = tableBuilder.integer(column.name);
-                    break;
-                default:
-                    columnBuilder = tableBuilder.string(column.name);
-            }
-            switch (column.nullConstraint) {
-                case 'null':
-                    columnBuilder.nullable();
-                    break;
-                default:
-                    columnBuilder.notNullable();
-            }
-            switch (column.index) {
-                case 'index':
-                    columnBuilder.index((0, exports.shortName)('IDX', table.name, column.name));
-                    break;
-                case 'primary':
-                    if (primaryKey.length) {
-                        columnBuilder.index((0, exports.shortName)('IDX', table.name, column.name));
-                    }
-                    primaryKey.push(column.name);
-                    break;
-                case 'unique':
-                    columnBuilder.unique({ indexName: (0, exports.shortName)('UNQ', table.name, column.name) });
-                    break;
-                default:
-            }
-            if (column.referencedTable) {
-                columnBuilder
-                    .references(column.name)
-                    .inTable(column.referencedTable)
-                    .withKeyName((0, exports.shortName)('FK', table.name, column.referencedTable, column.name))
-                    .onUpdate('CASCADE')
-                    .onDelete(column.onDelete ? column.onDelete.toUpperCase() : 'RESTRICT');
-            }
-        });
-        if (primaryKey.length) {
-            tableBuilder.primary(primaryKey);
-        }
-    });
-};
-exports.createTable = createTable;
-var dropTable = function (table) { return table.db.schema.dropTable(table.name); };
-exports.dropTable = dropTable;
-var table = function (db, name) { return ({ db: db, name: name }); };
-exports.table = table;
-var column = function (name, dataType, nullConstraint, index, referencedTable, onDelete) { return ({ name: name, dataType: dataType, nullConstraint: nullConstraint, index: index, referencedTable: referencedTable, onDelete: onDelete }); };
-exports.column = column;
-exports.default = {
-    column: exports.column,
-    createTable: exports.createTable,
-    dropTable: exports.dropTable,
-    shortName: exports.shortName,
-    table: exports.table,
-};

package/db/schema/builder/_.ts

@@ -1,101 +0,0 @@
-import type { Database } from '../../database'
-
-export interface Table {
-  db: Database,
-  name: string,
-}
-
-export interface Column {
-  name: string,
-  dataType: DataType,
-  nullConstraint: NullConstraint,
-  index?: Index,
-  referencedTable?: string,
-  onDelete?: OnDelete,
-}
-
-export type DataType = 'boolean' | 'decimal' | 'integer' | 'string'
-export type NullConstraint = 'notNull' | 'null'
-export type Index = 'index' | 'noIndex' | 'primary' | 'unique'
-export type OnDelete = 'cascade' | 'restrict'
-
-const longNameRegex = /[A-Z][a-z]{4,}|[a-z]{5,}/g
-
-export const shortName = (...name: string[]) => name
-  .map((string) => string.replace(longNameRegex, (match) => match.substring(0, 4)))
-  .join('_')
-
-export const createTable = (table: Table, ...columns: Column[]) => table.db.schema
-  .createTable(table.name, (tableBuilder) => {
-    const primaryKey: string[] = []
-    columns.forEach((column) => {
-      let columnBuilder: Database.ColumnBuilder
-      switch (column.dataType) {
-        case 'boolean':
-          columnBuilder = tableBuilder.boolean(column.name)
-          break
-        case 'decimal':
-          columnBuilder = tableBuilder.decimal(column.name, 32, 16)
-          break
-        case 'integer':
-          columnBuilder = tableBuilder.integer(column.name)
-          break
-        default:
-          columnBuilder = tableBuilder.string(column.name)
-      }
-      switch (column.nullConstraint) {
-        case 'null':
-          columnBuilder.nullable()
-          break
-        default:
-          columnBuilder.notNullable()
-      }
-      switch (column.index) {
-        case 'index':
-          columnBuilder.index(shortName('IDX', table.name, column.name))
-          break
-        case 'primary':
-          if (primaryKey.length) {
-            columnBuilder.index(shortName('IDX', table.name, column.name))
-          }
-          primaryKey.push(column.name)
-          break
-        case 'unique':
-          columnBuilder.unique({ indexName: shortName('UNQ', table.name, column.name) })
-          break
-        default:
-      }
-      if (column.referencedTable) {
-        columnBuilder
-          .references(column.name)
-          .inTable(column.referencedTable)
-          .withKeyName(shortName('FK', table.name, column.referencedTable, column.name))
-          .onUpdate('CASCADE')
-          .onDelete(column.onDelete ? column.onDelete.toUpperCase() : 'RESTRICT')
-      }
-    })
-    if (primaryKey.length) {
-      tableBuilder.primary(primaryKey)
-    }
-  })
-
-export const dropTable = (table: Table) => table.db.schema.dropTable(table.name)
-
-export const table = (db: Database, name: string): Table => ({ db, name })
-
-export const column = (
-  name: string,
-  dataType: DataType,
-  nullConstraint: NullConstraint,
-  index?: Index,
-  referencedTable?: string,
-  onDelete?: OnDelete,
-): Column => ({ name, dataType, nullConstraint, index, referencedTable, onDelete })
-
-export default {
-  column,
-  createTable,
-  dropTable,
-  shortName,
-  table,
-}

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

@@ -1,7 +0,0 @@
-import type { Database } from '../../database';
-export declare class ColumnBuilder {
-    private knexColumnBuilder;
-    constructor(knexColumnBuilder: Database.ColumnBuilder);
-    index(): void;
-}
-export default ColumnBuilder;

package/db/schema/builder/columnBuilder.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnBuilder = void 0;
-var ColumnBuilder = /** @class */ (function () {
-    function ColumnBuilder(knexColumnBuilder) {
-        this.knexColumnBuilder = knexColumnBuilder;
-    }
-    ColumnBuilder.prototype.index = function () {
-        this.knexColumnBuilder.index();
-    };
-    return ColumnBuilder;
-}());
-exports.ColumnBuilder = ColumnBuilder;
-exports.default = ColumnBuilder;

package/db/schema/builder/columnBuilder.ts

@@ -1,15 +0,0 @@
-import type { Database } from '../../database'
-
-export class ColumnBuilder {
-  private knexColumnBuilder: Database.ColumnBuilder
-
-  constructor(knexColumnBuilder: Database.ColumnBuilder) {
-    this.knexColumnBuilder = knexColumnBuilder
-  }
-
-  index() {
-    this.knexColumnBuilder.index()
-  }
-}
-
-export default ColumnBuilder

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

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

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;