generathor-laravel 1.0.0

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

@@ -0,0 +1,20 @@
+import { Configuration } from '../../configuration';
+import { Item, Relation } from 'generathor-db';
+type FKDetails = {
+    relationAttribute: string;
+    table: string;
+    context: string;
+    routeRecordName: string;
+};
+export type TransformedItem = Record<string, any>;
+export declare abstract class BaseTransformer {
+    protected $items: Item[];
+    protected $config: Configuration;
+    constructor($items: Item[], $config: Configuration);
+    abstract transform(): TransformedItem[];
+    protected mapByTable(): Record<string, Item>;
+    protected references(relation: Relation): Record<string, string>;
+    protected fksByTable(): Record<string, Record<string, FKDetails>>;
+    private fks;
+}
+export {};

package/dist/transformers/collection/base.js

@@ -0,0 +1,54 @@
+"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($items, $config) {
+        this.$items = $items;
+        this.$config = $config;
+    }
+    mapByTable() {
+        const map = {};
+        for (const item of this.$items) {
+            map[item.table] = item;
+        }
+        return map;
+    }
+    references(relation) {
+        const references = {};
+        for (const index in relation.references) {
+            references[relation.references[index]] = relation.columns[index];
+        }
+        return references;
+    }
+    fksByTable() {
+        const map = {};
+        for (const item of this.$items) {
+            map[item.table] = this.fks(item);
+        }
+        return map;
+    }
+    fks(item) {
+        const fks = {};
+        item.relations.forEach((relation) => {
+            if (relation.type !== 'belongs-to') {
+                return;
+            }
+            const relationColumnKeys = Object.keys(relation.columns);
+            const relationAttribute = naming_1.default.relationAttribute(relation, 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/collection/baseController.d.ts

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

package/dist/transformers/collection/baseController.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+const base_1 = require("./base");
+class BaseController extends base_1.BaseTransformer {
+    transform() {
+        return [
+            {
+                namespace: 'App\\Http\\Controllers\\Generathor',
+            },
+        ];
+    }
+}
+exports.BaseController = BaseController;

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

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

package/dist/transformers/collection/belongsToRelation.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToRelation = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+class BelongsToRelation 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 !== 'belongs-to') {
+                    continue;
+                }
+                const relationAttribute = naming_1.default.relationAttribute(relation, item.table);
+                const relatedItem = map[relation.on.table];
+                const fks = fksByTable[relation.on.table];
+                result.push({
+                    context,
+                    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,
+                    columns: relatedItem.columns.map((column) => {
+                        let type = column.type;
+                        let data = null;
+                        if (fks[column.name]) {
+                            type = 'record';
+                            data = fks[column.name];
+                        }
+                        return {
+                            data,
+                            type,
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            nullable: column.nullable,
+                        };
+                    }),
+                    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.BelongsToRelation = BelongsToRelation;

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

@@ -0,0 +1,8 @@
+import { BaseTransformer, TransformedItem } from './base';
+export declare class Controller extends BaseTransformer {
+    transform(): TransformedItem[];
+    private relationAttributes;
+    private attributes;
+    private searchData;
+    private queryRelations;
+}

package/dist/transformers/collection/controller.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+const ignoreAttributesFor = {
+    created_at: true,
+    updated_at: true,
+};
+class Controller extends base_1.BaseTransformer {
+    transform() {
+        const result = [];
+        const namespace = 'App\\Http\\Controllers\\Generathor';
+        const requestNamespace = 'App\\Http\\Requests\\Generathor';
+        const eloquentNamespace = 'App\\Models';
+        const itemsByTable = this.mapByTable();
+        for (const item of this.$items) {
+            const imports = {};
+            const hasManyRelations = [];
+            const belongsToRelations = [];
+            const model = naming_1.default.modelClass(item.table);
+            const context = naming_1.default.context(item.table);
+            const createRequest = `Create${model}Request`;
+            const updateRequest = `Update${model}Request`;
+            const filterRequest = `Filter${model}Request`;
+            imports[`${eloquentNamespace}\\${model}`] = true;
+            imports[`${requestNamespace}\\${createRequest}`] = true;
+            imports[`${requestNamespace}\\${updateRequest}`] = true;
+            imports[`${requestNamespace}\\${filterRequest}`] = true;
+            const controller = naming_1.default.controller(item.table);
+            const queryRelations = [];
+            for (const relation of item.relations) {
+                const label = naming_1.default.relationLabel(relation, item.table);
+                queryRelations.push(naming_1.default.relationAttribute(relation, item.table));
+                const capitalizedRelationAttribute = naming_1.default.capitalizedRelationAttribute(relation, item.table);
+                const relationContext = naming_1.default.relationContext(relation, item.table);
+                const relationModel = naming_1.default.modelClass(relation.on.table);
+                if (relation.type === 'has-many') {
+                    const relationAttribute = naming_1.default.relationAttribute(relation, item.table);
+                    const filterRequest = `Filter${relationModel}Request`;
+                    imports[`${requestNamespace}\\${filterRequest}`] = true;
+                    hasManyRelations.push({
+                        label,
+                        capitalizedRelationAttribute,
+                        relationContext,
+                        filterRequest,
+                        attribute: relationAttribute,
+                        model: relationModel,
+                        references: this.references(relation),
+                        queryRelations: this.queryRelations(relation, item, itemsByTable),
+                    });
+                }
+                else {
+                    const createRelationRequest = `Create${relationModel}Request`;
+                    const attachRelationRequest = `Attach${relationModel}To${model}Request`;
+                    imports[`${requestNamespace}\\${createRelationRequest}`] = true;
+                    imports[`${requestNamespace}\\${attachRelationRequest}`] = true;
+                    imports[`${eloquentNamespace}\\${relationModel}`] = true;
+                    const references = this.references(relation);
+                    const attributes = this.relationAttributes(relation, itemsByTable);
+                    belongsToRelations.push({
+                        label,
+                        attributes,
+                        capitalizedRelationAttribute,
+                        createRelationRequest,
+                        attachRelationRequest,
+                        relationContext,
+                        model: relationModel,
+                        references: references,
+                    });
+                }
+            }
+            imports['Illuminate\\Http\\Request'] = true;
+            result.push({
+                context,
+                namespace,
+                model,
+                createRequest,
+                updateRequest,
+                filterRequest,
+                hasManyRelations,
+                belongsToRelations,
+                search: this.searchData(item),
+                recordName: naming_1.default.recordName(item.table),
+                label: naming_1.default.singularLabel(item.table),
+                attributes: this.attributes(item),
+                class: controller,
+                imports: Object.keys(imports).sort(),
+                queryRelations: queryRelations.length
+                    ? `'${queryRelations.join("', '")}'`
+                    : null,
+            });
+        }
+        return result;
+    }
+    relationAttributes(relation, itemsByTable) {
+        const attributes = [];
+        const item = itemsByTable[relation.on.table];
+        for (const column of item.columns) {
+            if (column.autoincrement) {
+                continue;
+            }
+            if (ignoreAttributesFor[column.name]) {
+                continue;
+            }
+            attributes.push({
+                name: column.name,
+                type: column.type,
+            });
+        }
+        return attributes;
+    }
+    attributes(item) {
+        const attributes = [];
+        for (const column of item.columns) {
+            if (column.autoincrement) {
+                continue;
+            }
+            if (ignoreAttributesFor[column.name]) {
+                continue;
+            }
+            attributes.push({
+                name: column.name,
+                type: column.type,
+            });
+        }
+        return attributes;
+    }
+    searchData(item) {
+        if (!item.primaryKey || item.primaryKey.columns.length !== 1) {
+            return null;
+        }
+        const key = item.primaryKey.columns[0];
+        for (const column of item.columns) {
+            if (column.type === 'string') {
+                return {
+                    key,
+                    attribute: column.name,
+                };
+            }
+        }
+        return {
+            key,
+            attribute: item.columns[0].name,
+        };
+    }
+    queryRelations(currentRelation, item, itemsByTable) {
+        const queryRelations = [];
+        const relatedItem = itemsByTable[currentRelation.on.table];
+        for (const relation of relatedItem.relations) {
+            if (relation.on.table === item.table &&
+                relation.columns[0] === currentRelation.references[0]) {
+                continue;
+            }
+            queryRelations.push(naming_1.default.relationAttribute(relation, relatedItem.table));
+        }
+        return queryRelations.length ? `'${queryRelations.join("', '")}'` : null;
+    }
+}
+exports.Controller = Controller;

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

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

package/dist/transformers/collection/createRelationForm.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRelationForm = void 0;
+const base_1 = require("./base");
+const naming_1 = __importDefault(require("../../helpers/naming"));
+const ignoreInputsFor = {
+    created_at: true,
+    updated_at: true,
+};
+class CreateRelationForm 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) {
+                const isHasMayRelation = relation.type === 'has-many';
+                const itemRelated = map[relation.on.table];
+                const inputs = [];
+                const hiddenInputs = [];
+                const references = this.references(relation);
+                const fks = fksMap[itemRelated.table];
+                const recordName = naming_1.default.recordName(item.table);
+                itemRelated.columns.forEach((column) => {
+                    if (references[column.name]) {
+                        if (isHasMayRelation) {
+                            hiddenInputs.push({
+                                name: column.name,
+                                type: 'fixed',
+                                data: {
+                                    value: `$${recordName}->${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') {
+                        inputs.push({
+                            type: 'number',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            data: {
+                                decimals: 0,
+                            },
+                        });
+                        return;
+                    }
+                    if (column.type === 'float') {
+                        inputs.push({
+                            type: 'number',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                            data: {
+                                decimals: column.scale,
+                            },
+                        });
+                        return;
+                    }
+                    if (column.type === 'bool') {
+                        inputs.push({
+                            type: 'checkbox',
+                            name: column.name,
+                            label: naming_1.default.columnLabel(column),
+                        });
+                        return;
+                    }
+                    const dates = {
+                        datetime: true,
+                        time: true,
+                        date: true,
+                    };
+                    if (dates[column.subType]) {
+                        if (!ignoreInputsFor[column.name]) {
+                            inputs.push({
+                                type: column.subType,
+                                name: column.name,
+                                label: naming_1.default.columnLabel(column),
+                            });
+                        }
+                        return;
+                    }
+                    inputs.push({
+                        type: 'text',
+                        name: column.name,
+                        label: naming_1.default.columnLabel(column),
+                    });
+                });
+                const relationRouteContext = naming_1.default.context(itemRelated.table);
+                const parentContext = naming_1.default.context(item.table);
+                if (isHasMayRelation) {
+                    hiddenInputs.push({
+                        name: '_url',
+                        type: 'current_url',
+                    });
+                }
+                result.push({
+                    context,
+                    contextFile: naming_1.default.relationContext(relation, item.table),
+                    record: null,
+                    routeRecord: isHasMayRelation ? null : recordName,
+                    method: 'post',
+                    prefix: '',
+                    getOld: 'old',
+                    errorBag: 'create',
+                    buttonLabel: 'Save',
+                    buttonColor: 'green',
+                    columns: '2',
+                    route: isHasMayRelation
+                        ? `generathor.${relationRouteContext}.store`
+                        : `generathor.${parentContext}.store${naming_1.default.capitalizedRelationAttribute(relation, item.table)}`,
+                    cancelLink: null,
+                    inputs: inputs,
+                    hiddenInputs: hiddenInputs,
+                });
+            }
+        }
+        return result;
+    }
+}
+exports.CreateRelationForm = CreateRelationForm;

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

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