tspace-mysql 1.0.1 → 1.0.2

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/migrate/make.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (_ref: any) => void;
+export default _default;

package/dist/cli/models/make.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (_ref: any) => void;
+export default _default;

package/dist/cli/models/model.d.ts

@@ -0,0 +1,2 @@
+declare const Model: (model: string, npm: string) => string;
+export default Model;

package/dist/cli/tables/make.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (_ref: any) => void;
+export default _default;

package/dist/cli/tables/table.d.ts

@@ -0,0 +1,2 @@
+declare const Table: (model: string, npm: string) => string;
+export default Table;

package/dist/lib/config/env.d.ts

@@ -0,0 +1,8 @@
+declare const env: Readonly<{
+    DB_HOST: string | undefined;
+    DB_PORT: string | undefined;
+    DB_USERNAME: string | undefined;
+    DB_PASSWORD: string | undefined;
+    DB_DATABASE: string | undefined;
+}>;
+export default env;

package/dist/lib/connections/index.d.ts

@@ -0,0 +1,2 @@
+declare const pool: any;
+export default pool;

package/dist/lib/connections/options.d.ts

@@ -0,0 +1,4 @@
+declare const configs: {
+    [x: string]: string;
+};
+export default configs;

package/dist/lib/index.d.ts

@@ -0,0 +1,8 @@
+/**
+  * The entry point.
+  *
+  * @module tspace-myorm
+*/
+import * as tspace from './tspace';
+export * from './tspace';
+export default tspace;

package/dist/lib/tspace/AbstractDB.d.ts

@@ -0,0 +1,7 @@
+import Database from './Database';
+declare abstract class AbstractDB extends Database {
+    abstract table(tableName: string): void;
+    abstract raw(sql: string): Promise<any>;
+    abstract beginTransaction(): Promise<any>;
+}
+export default AbstractDB;

package/dist/lib/tspace/AbstractDatabase.d.ts

@@ -0,0 +1,102 @@
+declare abstract class AbstractDatabase {
+    protected _setters: string[];
+    protected $utils: Function;
+    protected $db: {
+        get: Function;
+        set: Function;
+    };
+    protected $logger: {
+        get: Function;
+        set: (arg: string) => void;
+        check: (arg: string) => boolean;
+    };
+    protected $attributes: {};
+    abstract debug(): void;
+    abstract dump(): void;
+    abstract dd(): void;
+    abstract select(...params: string[]): void;
+    abstract distinct(...params: string[]): void;
+    abstract whereNull(column: string): void;
+    abstract whereNotNull(column: string): void;
+    abstract where(column: string, operator: string, value: string): void;
+    abstract whereSensitive(column: string, operator: string, value: string): void;
+    abstract whereId(id: number): void;
+    abstract whereUser(id: number): void;
+    abstract whereEmail(value: string): void;
+    abstract whereGroupStart(column: string, operator: string, value: string): void;
+    abstract whereGroupEnd(column: string, operator: string, value: string): void;
+    abstract orWhereGroupStart(column: string, operator: string, value: string): void;
+    abstract orWhereGroupEnd(column: string, operator: string, value: string): void;
+    abstract orWhere(column: string, operator: string, value: string): void;
+    abstract whereIn(column: string, arrayValues: Array<any>): void;
+    abstract orWhereIn(column: string, arrayValues: Array<any>): void;
+    abstract whereNotIn(column: string, arrayValues: Array<any>): void;
+    abstract whereSubQuery(column: string, subQuery: string): void;
+    abstract whereNotInSubQuery(column: string, subQuery: string): void;
+    abstract orWhereSubQuery(column: string, subQuery: string): void;
+    abstract whereBetween(column: string, arrayValue: Array<any>): void;
+    abstract having(condition: string): void;
+    abstract join(pk: string, fk: string): void;
+    abstract rightJoin(pk: string, fk: string): void;
+    abstract leftJoin(pk: string, fk: string): void;
+    abstract crossJoin(pk: string, fk: string): void;
+    abstract orderBy(column: string, order: string): void;
+    abstract latest(column: string): void;
+    abstract oldest(column: string): void;
+    abstract groupBy(column: string): void;
+    abstract limit(number: number): void;
+    abstract hidden(...columns: string[]): void;
+    abstract insert(objects: object): void;
+    abstract create(objects: object): void;
+    abstract update(objects: object): void;
+    abstract insertNotExists(objects: object): void;
+    abstract createNotExists(objects: object): void;
+    abstract upsert(objects: object): void;
+    abstract insertOrUpdate(objects: object): void;
+    abstract createOrUpdate(objects: object): void;
+    abstract updateOrInsert(objects: object): void;
+    abstract updateOrCreate(objects: object): void;
+    abstract createMultiple(objects: object): void;
+    abstract insertMultiple(objects: object): void;
+    abstract except(...params: string[]): void;
+    abstract only(...params: string[]): void;
+    /**
+     *
+     * @Execute result
+     *
+    */
+    abstract drop(): Promise<any>;
+    abstract truncate(): Promise<any>;
+    abstract all(): Promise<any>;
+    abstract find(id: number): Promise<any>;
+    abstract pagination({ limit, page }: {
+        limit: number;
+        page: number;
+    }): Promise<any>;
+    abstract paginate({ limit, page }: {
+        limit: number;
+        page: number;
+    }): Promise<any>;
+    abstract first(): Promise<any>;
+    abstract get(): Promise<any>;
+    abstract findOne(): Promise<any>;
+    abstract findMany(): Promise<any>;
+    abstract getGroupBy(column: string): Promise<any>;
+    abstract findManyGroupBy(column: string): Promise<any>;
+    abstract toArray(column: string): Promise<any>;
+    abstract toJSON(): Promise<any>;
+    abstract toSQL(): string;
+    abstract toString(): string;
+    abstract count(column: string): Promise<any>;
+    abstract sum(column: string): Promise<any>;
+    abstract avg(column: string): Promise<any>;
+    abstract max(column: string): Promise<any>;
+    abstract min(column: string): Promise<any>;
+    abstract delete(): Promise<any>;
+    abstract exists(): Promise<any>;
+    abstract save(): Promise<any>;
+    abstract increment(column: string, value: number): Promise<any>;
+    abstract decrement(column: string, value: number): Promise<any>;
+    abstract faker(round: number): Promise<any>;
+}
+export default AbstractDatabase;

package/dist/lib/tspace/AbstractModel.d.ts

@@ -0,0 +1,20 @@
+import { Relation } from './Interface';
+import Database from './Database';
+declare abstract class AbstractModel extends Database {
+    abstract useDebug(): void;
+    abstract useTable(table: string): void;
+    abstract useTimestamp(): void;
+    abstract useSoftDelete(): void;
+    abstract usePattern(pattern: string): void;
+    abstract onlyTrashed(): void;
+    abstract trashed(): void;
+    abstract restore(): void;
+    abstract with(...nameRelations: string[]): void;
+    abstract withQuery(nameRelations: string, callback: Function): void;
+    abstract withExists(...nameRelations: string[]): void;
+    abstract hasOne({ name, model, pk, fk, freezeTable, child }: Relation): void;
+    abstract hasMany({ name, model, pk, fk, freezeTable, child }: Relation): void;
+    abstract belongsTo({ name, model, pk, fk, freezeTable, child }: Relation): void;
+    abstract belongsToMany({ name, model, pk, fk, freezeTable, child }: Relation): void;
+}
+export default AbstractModel;

package/dist/lib/tspace/DB.d.ts

@@ -0,0 +1,15 @@
+import AbstractDB from './AbstractDB';
+declare class DB extends AbstractDB {
+    [x: string]: {};
+    constructor();
+    table(table: string): this;
+    raw(sql: string): Promise<any[]>;
+    beginTransaction(): Promise<{
+        rollback: () => Promise<boolean>;
+        query: never[];
+    }>;
+    private _initDB;
+    private _setupLogger;
+    private _setupDB;
+}
+export default DB;

package/dist/lib/tspace/Database.d.ts

@@ -0,0 +1,151 @@
+import AbstractDatabase from './AbstractDatabase';
+declare class Database extends AbstractDatabase {
+    except(...params: Array<string>): this;
+    only(...params: Array<string>): this;
+    distinct(column?: string): this;
+    select(...params: string[]): this;
+    where(column: string, operator?: any, value?: any): this;
+    whereId(id: number): this;
+    whereEmail(email: string): this;
+    whereUser(id: number): this;
+    orWhere(column: string, operator?: any, value?: any): this;
+    whereIn(column: string, arrayValues: Array<any>): this;
+    orWhereIn(column: string, arrayValues: Array<any>): this;
+    whereNotIn(column: string, arrayValues: Array<any>): this;
+    whereSubQuery(column: string, subQuery: string): this;
+    whereNotInSubQuery(column: string, subQuery: string): this;
+    orWhereSubQuery(column: string, subQuery: string): this;
+    whereBetween(column: string, arrayValue: Array<any>): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereSensitive(column: string, operator?: any, value?: any): this;
+    whereGroupStart(column: string, operator?: any, value?: any): this;
+    orWhereGroupStart(column: string, operator?: any, value?: any): this;
+    whereGroupEnd(column: string, operator?: any, value?: any): this;
+    orWhereGroupEnd(column: string, operator?: any, value?: any): this;
+    having(condition: string): this;
+    join(pk: string, fk: string): this;
+    rightJoin(pk: string, fk: string): this;
+    leftJoin(pk: string, fk: string): this;
+    crossJoin(pk: string, fk: string): this;
+    orderBy(column: string, order?: any): this;
+    latest(column?: string): this;
+    oldest(column?: string): this;
+    groupBy(column: string): this;
+    limit(number?: number): this;
+    offset(number?: number): this;
+    hidden(...columns: Array<string>): this;
+    update(objects: object): this;
+    insert(objects: object): this;
+    create(objects: object): this;
+    createMultiple(data: Array<any>): this;
+    insertMultiple(data: Array<any>): this;
+    toString(): string;
+    toSQL(): string;
+    debug(debug?: boolean): this;
+    dump(debug?: boolean): this;
+    dd(debug?: boolean): this;
+    createNotExists(objects: object): this;
+    insertNotExists(objects: object): this;
+    upsert(objects: object): this;
+    updateOrCreate(objects: object): this;
+    updateOrInsert(objects: object): this;
+    insertOrUpdate(objects: object): this;
+    createOrUpdate(objects: object): this;
+    rawQuery(sql: string): Promise<any>;
+    increment(column?: string, value?: number): Promise<any>;
+    decrement(column?: string, value?: number): Promise<any>;
+    all(): Promise<any>;
+    find(id: number): Promise<any>;
+    pagination({ limit, page }?: {
+        limit?: number | undefined;
+        page?: number | undefined;
+    }): Promise<{
+        meta: {
+            total: number;
+            limit: number;
+            total_page: number;
+            current_page: number;
+            last_page: number;
+            next_page: number;
+            prev_page: number;
+        };
+        data: never[];
+    } | {
+        meta: {
+            total: number;
+            limit: number;
+            current_page: number;
+            last_page: number;
+            next_page: number;
+            prev_page: number;
+            total_page?: undefined;
+        };
+        data: any[];
+    }>;
+    paginate({ limit, page }?: {
+        limit?: number | undefined;
+        page?: number | undefined;
+    }): Promise<{
+        meta: {
+            total: number;
+            limit: number;
+            total_page: number;
+            current_page: number;
+            last_page: number;
+            next_page: number;
+            prev_page: number;
+        };
+        data: never[];
+    } | {
+        meta: {
+            total: number;
+            limit: number;
+            current_page: number;
+            last_page: number;
+            next_page: number;
+            prev_page: number;
+            total_page?: undefined;
+        };
+        data: any[];
+    }>;
+    first(): Promise<any>;
+    findOne(): Promise<any>;
+    get(): Promise<any[]>;
+    findMany(): Promise<any[]>;
+    toJSON(): Promise<string | never[]>;
+    toArray(column?: string): Promise<any[]>;
+    count(column?: string): Promise<any>;
+    exists(): Promise<boolean>;
+    avg(column?: string): Promise<any>;
+    sum(column?: string): Promise<any>;
+    max(column?: string): Promise<any>;
+    min(column?: string): Promise<any>;
+    delete(): Promise<boolean>;
+    getGroupBy(column: string): Promise<any>;
+    findManyGroupBy(column: string): Promise<any>;
+    save(transaction?: {
+        query: {
+            table: string;
+            id: string;
+        }[];
+    }): Promise<any>;
+    faker(rounds?: number): Promise<any>;
+    truncate(): Promise<boolean>;
+    drop(): Promise<boolean>;
+    private _insertNotExists;
+    private _queryStatement;
+    private _actionStatement;
+    private _create;
+    private _createMultiple;
+    private _updateOrInsert;
+    private _update;
+    private _hiddenColumn;
+    private _queryUpdate;
+    private _queryInsert;
+    private _queryInsertMultiple;
+    private _valueAndOperator;
+    private _valueTrueFalse;
+    private _getSQL;
+}
+export default Database;

package/dist/lib/tspace/Interface.d.ts

@@ -0,0 +1,25 @@
+export interface Relation {
+    name: string;
+    model: any;
+    as?: string;
+    pk?: string | undefined;
+    fk?: string | undefined;
+    select?: string | undefined;
+    hidden?: string | undefined;
+    freezeTable?: string | undefined;
+    query?: Object | undefined;
+    relation?: Object | undefined;
+    child?: boolean | undefined;
+}
+export interface RelationShip {
+    hasOne: string;
+    hasMany: string;
+    belongsTo: string;
+    belongsToMany: string;
+}
+export interface RelationShipChild {
+    hasOne: string;
+    hasMany: string;
+    belongsTo: string;
+}
+export declare type Pattern = 'snake_case' | 'camelCase';

package/dist/lib/tspace/Logger.d.ts

@@ -0,0 +1 @@
+export declare const LoggerMethod: (self: any, prop: string) => void;

package/dist/lib/tspace/Model.d.ts

@@ -0,0 +1,231 @@
+import AbstractModel from './AbstractModel';
+import { Relation } from './Interface';
+declare class Model extends AbstractModel {
+    [x: string]: {};
+    constructor();
+    useRegistry(): this;
+    useUUID(custom?: string): this;
+    useDebug(): this;
+    usePattern(pattern: string): this;
+    useSoftDelete(): this;
+    useTimestamp(): this;
+    useTable(table: string): this;
+    disabledSoftDelete(): this;
+    registry(func: any): this;
+    withQuery(name: string, cb: Function): this;
+    with(...nameRelations: Array<any>): this;
+    withExists(...nameRelations: Array<string>): this;
+    whereUser(id: number): this;
+    hasOne({ name, as, model, pk, fk, freezeTable }: Relation): this;
+    hasMany({ name, as, model, pk, fk, freezeTable }: Relation): this;
+    belongsTo({ name, as, model, pk, fk, freezeTable }: Relation): this;
+    belongsToMany({ name, as, model, pk, fk, freezeTable }: Relation): this;
+    trashed(): Promise<any>;
+    onlyTrashed(): Promise<any>;
+    restore(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    toString(): string;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    toSQL(): string;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    toJSON(): Promise<string | never[]>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    toArray(column?: string): Promise<any[]>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    avg(column?: string): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    sum(column?: string): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    max(column?: string): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    min(column?: string): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    count(column?: string): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    delete(): Promise<boolean>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    first(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    all(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    find(id: number): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    findOne(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    get(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    findMany(): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    pagination({ limit, page }?: {
+        limit?: number | undefined;
+        page?: number | undefined;
+    }): Promise<any>;
+    paginate({ limit, page }?: {
+        limit?: number | undefined;
+        page?: number | undefined;
+    }): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    getGroupBy(column: string): Promise<any>;
+    /**
+    *
+    * @Override Method
+    *
+   */
+    update(objects: object): this;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    insert(objects: object): this;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    create(objects: object): this;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    updateOrCreate(objects: object): this;
+    updateOrInsert(objects: object): this;
+    insertOrUpdate(objects: object): this;
+    createOrUpdate(objects: object): this;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    createMultiple(data: Array<any>): this;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    insertMultiple(data: Array<any>): this;
+    private _queryStatementModel;
+    private _actionStatementModel;
+    private _isPatternSnakeCase;
+    private _classToTableName;
+    private _tableName;
+    private _valueInRelation;
+    private _getSQLModel;
+    private _exceptColumns;
+    private _showOnly;
+    private _exec;
+    private _execGroup;
+    private _relationFilter;
+    private _relation;
+    private _belongsToMany;
+    private _pagination;
+    private _result;
+    private _returnEmpty;
+    private _returnResult;
+    private _hiddenColumnModel;
+    private _attach;
+    private _detach;
+    private _queryUpdateModel;
+    private _queryInsertModel;
+    private _queryInsertMultipleModel;
+    private _registry;
+    private _insertNotExistsModel;
+    private _createModel;
+    private _createMultipleModel;
+    private _updateOrInsertModel;
+    private _updateModel;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    save(transaction?: {
+        query: {
+            table: string;
+            id: string;
+        }[];
+    }): Promise<any>;
+    /**
+     *
+     * @Override Method
+     *
+    */
+    faker(rounds?: number): Promise<any>;
+    private _initModel;
+    private _setupLogger;
+    private _setupModel;
+}
+export default Model;

package/dist/lib/tspace/ProxyHandler.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    set: (target: any, name: string, value: any) => boolean;
+    get: (target: any, prop: any, value: any) => any;
+};
+export default _default;

package/dist/lib/tspace/Schema.d.ts

@@ -0,0 +1,44 @@
+import Database from "./Database";
+export declare class Schema extends Database {
+    protected timeStamp: Array<string>;
+    table: (table: string, schemas: any) => Promise<void>;
+}
+export declare class Blueprint {
+    protected type: string | undefined;
+    protected attrbuites: Array<string>;
+    private _addType;
+    private _addAttrbuite;
+    /**
+     *
+     * @Types
+     *
+    */
+    int(): this;
+    tinyInt(n?: number): this;
+    bigInt(n?: number): this;
+    double(): this;
+    float(): this;
+    varchar(n?: number): this;
+    char(n?: number): this;
+    longText(): this;
+    mediumText(): this;
+    tinyText(): this;
+    text(): this;
+    enum(...n: Array<string>): this;
+    date(): this;
+    dateTime(): this;
+    timestamp(): this;
+    /**
+     *
+     * @Attrbuites
+     *
+    */
+    unsigned(): this;
+    unique(): this;
+    null(): this;
+    notNull(): this;
+    primary(): this;
+    default(n: string): this;
+    defaultTimestamp(): this;
+    autoIncrement(): this;
+}

package/dist/lib/tspace/index.d.ts

@@ -0,0 +1,14 @@
+import DB from './DB';
+import Model from './Model';
+import { Schema, Blueprint } from './Schema';
+export { DB };
+export { Model };
+export { Schema };
+export { Blueprint };
+declare const _default: {
+    DB: typeof DB;
+    Model: typeof Model;
+    Schema: typeof Schema;
+    Blueprint: typeof Blueprint;
+};
+export default _default;

package/dist/lib/utils/constant.d.ts

@@ -0,0 +1,4 @@
+declare const constant: {
+    [x: string]: any;
+};
+export default constant;

package/dist/lib/utils/index.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    consoleDebug: (message?: string | undefined) => void;
+    tableName: (name: string) => string;
+    faker: (value: string) => string | number | boolean;
+    connection: () => Promise<any>;
+    columnRelation: (name: string) => string;
+    timestamp: () => string;
+    date: () => string;
+    escape: (str: any) => any;
+    escapeSubQuery: (str: any) => any;
+    generateUUID: () => string;
+    constants: (name?: string | undefined) => any;
+    covertBooleanToNumber: (data: any) => any;
+    snakeCase: (obj: any) => any;
+    camelCase: (obj: any) => any;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspace-mysql",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",