generathor-laravel 1.0.0

package/dist/transformers/collection/filterRelationForm.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterRelationForm = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class FilterRelationForm extends base_1.BaseTransformer {
+    transform() {
+        const map = this.mapByTable();
+        const result = [];
+        const fksMap = this.fksByTable();
+        for (const item of this.$items) {
+            const context = naming_1.default.context(item.table);
+            for (const relation of item.relations) {
+                if (relation.type !== 'has-many') {
+                    continue;
+                }
+                const itemRelated = map[relation.on.table];
+                const inputs = [];
+                const hiddenInputs = [];
+                const references = this.references(relation);
+                const fks = fksMap[itemRelated.table];
+                itemRelated.columns.forEach((column) => {
+                    if (references[column.name]) {
+                        return;
+                    }
+                    if (column.autoincrement) {
+                        return;
+                    }
+                    if (fks[column.name]) {
+                        inputs.push({
+                            type: 'record',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            data: {
+                                context: naming_1.default.context(fks[column.name].table),
+                                relationName: fks[column.name].relationAttribute,
+                            },
+                        });
+                        return;
+                    }
+                    if (column.type === 'string' &&
+                        column.enum &&
+                        Array.isArray(column.enum) &&
+                        column.enum.length > 0) {
+                        inputs.push({
+                            type: 'select',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            data: {
+                                options: [
+                                    {
+                                        value: '',
+                                        label: 'Select',
+                                    },
+                                ].concat(column.enum.map(function (value) {
+                                    return {
+                                        value: value,
+                                        label: naming_1.default.label(value),
+                                    };
+                                })),
+                            },
+                        });
+                        return;
+                    }
+                    if (column.type === 'int' || column.type === 'float') {
+                        const decimals = column.type === 'int' ? 0 : column.scale;
+                        inputs.push({
+                            type: 'number',
+                            name: column.name + '_from',
+                            label: naming_1.default.label(column.name + '_from'),
+                            data: {
+                                decimals,
+                            },
+                        });
+                        inputs.push({
+                            type: 'number',
+                            name: column.name + '_to',
+                            label: naming_1.default.label(column.name + '_to'),
+                            data: {
+                                decimals,
+                            },
+                        });
+                        return;
+                    }
+                    if (column.type === 'bool') {
+                        inputs.push({
+                            type: 'select',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            data: {
+                                options: [
+                                    {
+                                        value: '',
+                                        label: 'Select',
+                                    },
+                                    {
+                                        value: '0',
+                                        label: 'No',
+                                    },
+                                    {
+                                        value: '1',
+                                        label: 'Yes',
+                                    },
+                                ],
+                            },
+                        });
+                        return;
+                    }
+                    const dates = {
+                        datetime: true,
+                        time: true,
+                        date: true,
+                    };
+                    if (dates[column.subType]) {
+                        inputs.push({
+                            type: column.subType,
+                            name: column.name + '_from',
+                            label: naming_1.default.label(column.name + '_from'),
+                        });
+                        inputs.push({
+                            type: column.subType,
+                            name: column.name + '_to',
+                            label: naming_1.default.label(column.name + '_to'),
+                        });
+                        return;
+                    }
+                    inputs.push({
+                        type: 'text',
+                        name: column.name,
+                        label: naming_1.default.columnLabel(column),
+                    });
+                });
+                result.push({
+                    context,
+                    contextFile: naming_1.default.relationContext(relation, item.table),
+                    record: null,
+                    routeRecord: null,
+                    method: 'get',
+                    prefix: 'filter_',
+                    getOld: 'request',
+                    errorBag: 'filter',
+                    buttonLabel: 'Filter',
+                    buttonColor: 'blue',
+                    columns: '4',
+                    route: '',
+                    cancelLink: {
+                        label: 'Clear filters',
+                        route: 'request()->url()',
+                        icon: `<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="h-4 w-4">
+                        <path stroke-linecap="round" stroke-linejoin="round" d="M6 18 18 6M6 6l12 12" />
+                    </svg>`,
+                    },
+                    inputs: inputs,
+                    hiddenInputs: hiddenInputs,
+                });
+            }
+        }
+        return result;
+    }
+}
+exports.FilterRelationForm = FilterRelationForm;

package/dist/transformers/collection/hasManyRelation.d.ts

@@ -0,0 +1,5 @@
+import { BaseTransformer, TransformedItem } from './base';
+export declare class HasManyRelation extends BaseTransformer {
+    transform(): TransformedItem[];
+    private tabs;
+}

package/dist/transformers/collection/hasManyRelation.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelation = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class HasManyRelation extends base_1.BaseTransformer {
+    transform() {
+        const result = [];
+        const fksByTable = this.fksByTable();
+        const map = this.mapByTable();
+        for (const item of this.$items) {
+            const context = naming_1.default.context(item.table);
+            const listLabel = naming_1.default.listLabel(item.table);
+            const recordName = naming_1.default.recordName(item.table);
+            for (const relation of item.relations) {
+                if (relation.type !== 'has-many') {
+                    continue;
+                }
+                const relationAttribute = naming_1.default.relationAttribute(relation, item.table);
+                const columns = [];
+                const references = this.references(relation);
+                const fks = fksByTable[relation.on.table];
+                map[relation.on.table].columns.forEach((column) => {
+                    if (references[column.name]) {
+                        return;
+                    }
+                    let type = column.type;
+                    let data = null;
+                    if (fks[column.name]) {
+                        type = 'record';
+                        data = fks[column.name];
+                    }
+                    columns.push({
+                        data,
+                        type,
+                        name: column.name,
+                        label: naming_1.default.columnLabel(column),
+                        nullable: column.nullable,
+                    });
+                });
+                result.push({
+                    context,
+                    columns,
+                    layout: this.$config.layout(),
+                    homeRoute: this.$config.homeRoute(),
+                    header: listLabel,
+                    listLabel: listLabel,
+                    relationLabel: naming_1.default.relationLabel(relation, item.table),
+                    relationListLabel: naming_1.default.listLabel(relation.on.table),
+                    record: recordName,
+                    routeRelationRecordName: naming_1.default.recordName(relation.on.table),
+                    capitalizedRelationAttribute: naming_1.default.capitalizedRelationAttribute(relation, item.table),
+                    relationContext: naming_1.default.relationContext(relation, item.table),
+                    routeRelationContext: naming_1.default.context(relation.on.table),
+                    relationAttribute: relationAttribute,
+                    tabs: this.tabs(context, item, recordName, relationAttribute),
+                });
+            }
+        }
+        return result;
+    }
+    tabs(context, item, recordName, relationAttribute) {
+        const tabs = [];
+        tabs.push({
+            label: 'Details',
+            route: `generathor.${context}.show`,
+            routeRecord: recordName,
+        });
+        for (const relation of item.relations) {
+            const currentRelationAttribute = naming_1.default.relationAttribute(relation, item.table);
+            const relationLabel = naming_1.default.relationLabel(relation, item.table);
+            if (currentRelationAttribute === relationAttribute) {
+                tabs.push({
+                    label: relationLabel,
+                });
+                continue;
+            }
+            const capitalizedRelationAttribute = naming_1.default.capitalizedRelationAttribute(relation, item.table);
+            tabs.push({
+                label: relationLabel,
+                route: `generathor.${context}.show${capitalizedRelationAttribute}`,
+                routeRecord: recordName,
+            });
+        }
+        return tabs;
+    }
+}
+exports.HasManyRelation = HasManyRelation;

package/dist/transformers/collection/menu.d.ts

@@ -0,0 +1,4 @@
+import { BaseTransformer, TransformedItem } from './base';
+export declare class Menu extends BaseTransformer {
+    transform(): TransformedItem[];
+}

package/dist/transformers/collection/menu.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Menu = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class Menu extends base_1.BaseTransformer {
+    transform() {
+        return [
+            {
+                layout: this.$config.layout(),
+                homeRoute: this.$config.homeRoute(),
+                items: this.$items.map((item) => {
+                    return {
+                        context: naming_1.default.context(item.table),
+                        label: naming_1.default.listLabel(item.table),
+                    };
+                }),
+            },
+        ];
+    }
+}
+exports.Menu = Menu;

package/dist/transformers/collection/route.d.ts

@@ -0,0 +1,5 @@
+import { BaseTransformer, TransformedItem } from './base';
+export declare class Route extends BaseTransformer {
+    transform(): TransformedItem[];
+    private controller;
+}

package/dist/transformers/collection/route.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class Route extends base_1.BaseTransformer {
+    transform() {
+        const result = [];
+        for (const item of this.$items) {
+            const routes = [];
+            const context = naming_1.default.context(item.table);
+            const controller = this.controller(item.table);
+            routes.push({
+                context,
+                method: 'get',
+                path: context,
+                action: 'index',
+                precognition: true,
+            });
+            routes.push({
+                context,
+                method: 'post',
+                path: context,
+                action: 'store',
+                precognition: true,
+            });
+            if (item.primaryKey && item.primaryKey.columns.length === 1) {
+                routes.push({
+                    context,
+                    method: 'get',
+                    path: `${context}/search`,
+                    action: 'search',
+                    precognition: false,
+                });
+            }
+            const recordName = naming_1.default.recordName(item.table);
+            routes.push({
+                context,
+                method: 'get',
+                path: `${context}/{${recordName}}`,
+                action: 'show',
+                precognition: false,
+            });
+            routes.push({
+                context,
+                method: 'get',
+                path: `${context}/{${recordName}}/edit`,
+                action: 'edit',
+                precognition: false,
+            });
+            routes.push({
+                context,
+                method: 'put',
+                path: `${context}/{${recordName}}`,
+                action: 'update',
+                precognition: true,
+            });
+            routes.push({
+                context,
+                method: 'delete',
+                path: `${context}/{${recordName}}`,
+                action: 'destroy',
+                precognition: false,
+            });
+            for (const relation of item.relations) {
+                const relationContext = naming_1.default.relationContext(relation, item.table);
+                const relationName = naming_1.default.capitalizedRelationAttribute(relation, item.table);
+                if (relation.type === 'has-many') {
+                    routes.push({
+                        context,
+                        method: 'get',
+                        path: `${context}/{${recordName}}/${relationContext}`,
+                        action: 'show' + relationName,
+                        precognition: true,
+                    });
+                }
+                else {
+                    routes.push({
+                        context,
+                        method: 'get',
+                        path: `${context}/{${recordName}}/${relationContext}`,
+                        action: 'show' + relationName,
+                        precognition: false,
+                    });
+                    routes.push({
+                        context,
+                        method: 'post',
+                        path: `${context}/{${recordName}}/${relationContext}`,
+                        action: 'store' + relationName,
+                        precognition: true,
+                    });
+                    routes.push({
+                        context,
+                        method: 'post',
+                        path: `${context}/{${recordName}}/${relationContext}/attach`,
+                        action: 'attach' + relationName,
+                        precognition: true,
+                    });
+                    routes.push({
+                        context,
+                        method: 'post',
+                        path: `${context}/{${recordName}}/${relationContext}/detach`,
+                        action: 'detach' + relationName,
+                        precognition: true,
+                    });
+                }
+            }
+            result.push({
+                controller,
+                label: naming_1.default.listLabel(item.table),
+                routes,
+            });
+        }
+        return result;
+    }
+    controller(table) {
+        return 'App\\Http\\Controllers\\Generathor\\' + naming_1.default.controller(table);
+    }
+}
+exports.Route = Route;

package/dist/transformers/item/base.d.ts

@@ -0,0 +1,19 @@
+import { Configuration } from '../../configuration';
+import { Item } from 'generathor-db';
+export interface CurrentItem extends Item {
+    [x: string | number | symbol]: any;
+}
+type FKDetails = {
+    relationAttribute: string;
+    table: string;
+    context: string;
+    routeRecordName: string;
+};
+export declare abstract class BaseTransformer {
+    protected $item: CurrentItem;
+    protected $config: Configuration;
+    constructor($item: CurrentItem, $config: Configuration);
+    abstract transform(): void;
+    protected fks(): Record<string, FKDetails>;
+}
+export {};

package/dist/transformers/item/base.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTransformer = void 0;
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class BaseTransformer {
+    constructor($item, $config) {
+        this.$item = $item;
+        this.$config = $config;
+    }
+    fks() {
+        const fks = {};
+        this.$item.relations.forEach((relation) => {
+            if (relation.type !== 'belongs-to') {
+                return;
+            }
+            const relationColumnKeys = Object.keys(relation.columns);
+            const relationAttribute = naming_1.default.relationAttribute(relation, this.$item.table);
+            if (relationColumnKeys.length === 1) {
+                fks[relation.columns[0]] = {
+                    relationAttribute,
+                    table: relation.on.table,
+                    context: naming_1.default.context(relation.on.table),
+                    routeRecordName: naming_1.default.recordName(relation.on.table),
+                };
+            }
+        });
+        return fks;
+    }
+}
+exports.BaseTransformer = BaseTransformer;

package/dist/transformers/item/edit.d.ts

@@ -0,0 +1,4 @@
+import { BaseTransformer } from './base';
+export declare class Edit extends BaseTransformer {
+    transform(): void;
+}

package/dist/transformers/item/edit.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Edit = void 0;
+const naming_1 = __importDefault(require("../../helpers/naming"));
+const base_1 = require("./base");
+class Edit extends base_1.BaseTransformer {
+    transform() {
+        this.$item.laravel.edit = {
+            layout: this.$config.layout(),
+            homeRoute: this.$config.homeRoute(),
+            context: naming_1.default.context(this.$item.table),
+            header: naming_1.default.listLabel(this.$item.table),
+            listLabel: naming_1.default.listLabel(this.$item.table),
+            recordName: naming_1.default.recordName(this.$item.table),
+        };
+    }
+}
+exports.Edit = Edit;

package/dist/transformers/item/eloquent.d.ts

@@ -0,0 +1,4 @@
+import { BaseTransformer } from './base';
+export declare class Eloquent extends BaseTransformer {
+    transform(): void;
+}

package/dist/transformers/item/eloquent.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Eloquent = void 0;
+const naming_1 = __importDefault(require("../../helpers/naming"));
+const type = __importStar(require("../../helpers/type"));
+const base_1 = require("./base");
+class Eloquent extends base_1.BaseTransformer {
+    transform() {
+        const primaryKey = this.$item.primaryKey.columns.length === 0
+            ? [this.$item.columns[0].name]
+            : this.$item.primaryKey.columns;
+        const result = {
+            model: naming_1.default.modelClass(this.$item.table),
+            table: this.$item.table,
+            imports: [],
+            namespace: 'App\\Models',
+            recordLabel: null,
+            belongsToRelations: [],
+            hasManyRelations: [],
+            attributes: [],
+            primaryKey: primaryKey.length === 1
+                ? `'${primaryKey[0]}'`
+                : `['${primaryKey.join("', '")}']`,
+            onlyReadAttributes: [],
+            autoincrement: false,
+            timestamps: false,
+            constants: [],
+        };
+        const imports = {
+            [this.$config.eloquentParent(this.$item.table)]: true,
+            'Kyslik\\ColumnSortable\\Sortable': true,
+            'EloquentFilter\\Filterable': true,
+        };
+        let importCollection = false;
+        this.$item.relations.forEach((relation) => {
+            let relationClass = naming_1.default.modelClass(relation.on.table);
+            const relationName = naming_1.default.relationAttribute(relation, this.$item.table);
+            if (relation.on.table !== this.$item.table) {
+                imports['App\\Models\\' + relationClass] = true;
+            }
+            else {
+                imports[`App\\Models\\${relationClass} as ChildModel`] = true;
+                relationClass = 'ChildModel';
+            }
+            let attributeType = relationClass;
+            if (relation.type === 'has-many') {
+                attributeType = `Collection<${attributeType}>`;
+                importCollection = true;
+            }
+            result.onlyReadAttributes.push({
+                name: relationName,
+                type: attributeType,
+            });
+            const columns = {};
+            let reference = null;
+            if (relation.columns.length === 1) {
+                reference =
+                    relation.type === 'has-many'
+                        ? {
+                            foreignKey: relation.references[0],
+                            localKey: relation.columns[0],
+                        }
+                        : {
+                            foreignKey: relation.columns[0],
+                            ownerKey: relation.references[0],
+                        };
+            }
+            for (const index in relation.columns) {
+                columns[relation.references[index]] = relation.columns[index];
+            }
+            if (relation.type === 'has-many') {
+                result.hasManyRelations.push({
+                    reference,
+                    name: relationName,
+                    model: relationClass,
+                });
+            }
+            else {
+                result.belongsToRelations.push({
+                    reference,
+                    name: relationName,
+                    model: relationClass,
+                });
+            }
+        });
+        let firstStringColumn = null;
+        const firstColumn = this.$item.columns[0].name;
+        let autoincrement = false;
+        const timestamps = {
+            created_at: false,
+            updated_at: false,
+        };
+        this.$item.columns.forEach((column) => {
+            if (column.enum && Array.isArray(column.enum)) {
+                column.enum.forEach((value) => {
+                    result.constants.push({
+                        name: `${column.name}_${value}`.toUpperCase(),
+                        value: value,
+                    });
+                });
+            }
+            if (!firstStringColumn && column.type === 'string') {
+                firstStringColumn = column.name;
+            }
+            if (!autoincrement && column.autoincrement) {
+                autoincrement = true;
+            }
+            if (!timestamps.created_at && column.name === 'created_at') {
+                timestamps.created_at = true;
+            }
+            if (!timestamps.updated_at && column.name === 'updated_at') {
+                timestamps.updated_at = true;
+            }
+            if (column.type === 'date') {
+                imports['Illuminate\\Support\\Carbon'] = true;
+            }
+            result.attributes.push({
+                type: type.phpType(column.type),
+                name: column.name,
+            });
+        });
+        result.recordLabel = firstStringColumn || firstColumn;
+        result.autoincrement = autoincrement;
+        result.timestamps = timestamps.created_at && timestamps.updated_at;
+        if (importCollection) {
+            imports['Illuminate\\Database\\Eloquent\\Collection'] = true;
+        }
+        result.imports = Object.keys(imports).sort();
+        this.$item.laravel.eloquent = result;
+    }
+}
+exports.Eloquent = Eloquent;

package/dist/transformers/item/filter.d.ts

@@ -0,0 +1,5 @@
+import { BaseTransformer } from './base';
+export declare class Filter extends BaseTransformer {
+    transform(): void;
+    private pkMap;
+}