@quillsql/react 2.15.2 → 2.15.4

package/dist/cjs/utils/reportBuilder.d.ts

@@ -1,97 +0,0 @@
-import { ForeignKeyMap } from '../components/ReportBuilder/schema';
-import { Column, ColumnInternal } from '../models/Columns';
-import { Pivot } from '../models/Pivot';
-import { ReportBuilderState, ReportBuilderTable, JoinType } from '../models/ReportBuilder';
-import { Table, UniqueValuesByColumn } from '../models/Tables';
-export declare const reportBuilderStateToAst: (reportBuilderState: ReportBuilderState, databaseType: string) => {
-    from: {
-        db: null;
-        table: string;
-        as: string | null;
-        join: JoinType | null;
-        on: {
-            type: string;
-            operator: string;
-            left: {
-                type: string;
-                table: string;
-                column: string;
-            };
-            right: {
-                type: string;
-                table: string;
-                column: string;
-            };
-        } | null;
-    }[];
-    columns: {
-        expr: {
-            type: string;
-            table: string;
-            column: string;
-        };
-        as: string | null;
-    }[] | null;
-    where: any;
-    orderby: {
-        expr: {
-            type: string;
-            table: null;
-            column: string;
-        };
-        type: import("../models/ReportBuilder").SortDirection;
-    }[] | null;
-    limit: {
-        value: number;
-        percent: null;
-        seperator?: undefined;
-    } | {
-        seperator: string;
-        value: {
-            type: string;
-            value: number;
-        }[];
-        percent?: undefined;
-    } | null;
-    top: {
-        value: number;
-        percent: null;
-        seperator?: undefined;
-    } | {
-        seperator: string;
-        value: {
-            type: string;
-            value: number;
-        }[];
-        percent?: undefined;
-    } | null;
-    with: null;
-    type: string;
-    options: null;
-    distinct: {
-        type: null;
-    };
-    into: {
-        position: null;
-    };
-    groupby: null;
-    having: null;
-    window: null;
-};
-export declare const astToReportBuilderState: (ast: any, databaseType: string, schema: Table[]) => ReportBuilderState;
-export declare const isValidPivotForReport: (pivot: Pivot, uniqueValuesByColumn: UniqueValuesByColumn, reportColumns: ColumnInternal[]) => boolean;
-export declare const makePivotValid: (pivot: Pivot, uniqueValuesForPivot: UniqueValuesByColumn, reportColumns: ColumnInternal[]) => {
-    pivot: Pivot | null;
-    hint: string;
-};
-export declare const formatRows: (rows: any[], columns: Column[], pivot?: boolean, aggregationType?: string, dateBucket?: string) => any;
-export declare const setTypesOnPivot: (newPivot: Pivot, searchColumns: ColumnInternal[]) => Pivot;
-export declare const orderTablesByBestPrimaryTable: (tables: ReportBuilderTable[], foreignKeyMap: {
-    [table: string]: {
-        foreignTable: string;
-        foreignTablePrimaryKey: string;
-        foreignKey: string;
-    }[];
-}) => ReportBuilderTable[];
-export declare const validatedReportBuilderState: (state: ReportBuilderState, foreignKeyMap: ForeignKeyMap) => ReportBuilderState;
-//# sourceMappingURL=reportBuilder.d.ts.map

package/dist/cjs/utils/reportBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reportBuilder.d.ts","sourceRoot":"","sources":["../../../src/utils/reportBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAEnE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAEL,kBAAkB,EAGlB,kBAAkB,EAElB,QAAQ,EACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAmC/D,eAAO,MAAM,uBAAuB,GAClC,oBAAoB,kBAAkB,EACtC,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBrB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,KAAK,GAAG,EACR,cAAc,MAAM,EACpB,QAAQ,KAAK,EAAE,KACd,kBAuBF,CAAC;AA2OF,eAAO,MAAM,qBAAqB,GAChC,OAAO,KAAK,EACZ,sBAAsB,oBAAoB,EAC1C,eAAe,cAAc,EAAE,YAuChC,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,OAAO,KAAK,EACZ,sBAAsB,oBAAoB,EAC1C,eAAe,cAAc,EAAE,KAC9B;IAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAgCrC,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,MAAM,GAAG,EAAE,EACX,SAAS,MAAM,EAAE,EACjB,QAAQ,OAAO,EACf,kBAAkB,MAAM,EACxB,aAAa,MAAM,QA6CpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,UAAU,KAAK,EACf,eAAe,cAAc,EAAE,KAoBzB,KAAK,CAAC;AAEd,eAAO,MAAM,6BAA6B,GACxC,QAAQ,kBAAkB,EAAE,EAC5B,eAAe;IACb,CAAC,KAAK,EAAE,MAAM,GAAG;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,UAAU,EAAE,MAAM,CAAC;KACpB,EAAE,CAAC;CACL,yBAqCF,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,OAAO,kBAAkB,EACzB,eAAe,aAAa,KAC3B,kBAoGF,CAAC"}

package/dist/cjs/utils/reportBuilder.js

@@ -1,524 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatedReportBuilderState = exports.orderTablesByBestPrimaryTable = exports.setTypesOnPivot = exports.formatRows = exports.makePivotValid = exports.isValidPivotForReport = exports.astToReportBuilderState = exports.reportBuilderStateToAst = void 0;
-const convert_1 = require("../components/ReportBuilder/convert");
-const util_1 = require("../components/ReportBuilder/util");
-const ReportBuilder_1 = require("../models/ReportBuilder");
-const astFilterProcessing_1 = require("./astFilterProcessing");
-const dates_1 = require("./dates");
-const filterProcessing_1 = require("./filterProcessing");
-const pivotProcessing_1 = require("./pivotProcessing");
-const valueFormatter_1 = require("./valueFormatter");
-const baseAstForReportBuilder = {
-    with: null,
-    type: 'select',
-    options: null,
-    distinct: {
-        type: null,
-    },
-    columns: [],
-    into: {
-        position: null,
-    },
-    from: [],
-    where: null,
-    groupby: null,
-    having: null,
-    orderby: null,
-    limit: null,
-    window: null,
-};
-// Primary conversion functions
-const reportBuilderStateToAst = (reportBuilderState, databaseType) => {
-    const astFrom = tableToAstFrom(reportBuilderState.tables);
-    const astColumns = columnsToAstColumns(reportBuilderState.columns);
-    const filterTree = reportBuilderState.filterStack && reportBuilderState.filterStack.length > 0
-        ? (0, filterProcessing_1.filterStackToFilterTree)(reportBuilderState.filterStack)
-        : null;
-    const astWhere = filterTree
-        ? (0, astFilterProcessing_1.filterTreeToAst)(filterTree, databaseType)
-        : null;
-    const astOrderby = sortToAstOrderBy(reportBuilderState.sort);
-    const astLimit = limitToAstLimit(reportBuilderState.limit, databaseType);
-    return {
-        ...baseAstForReportBuilder,
-        from: astFrom,
-        columns: astColumns,
-        where: astWhere,
-        orderby: astOrderby,
-        limit: databaseType.toLowerCase() === 'mssql' ? null : astLimit,
-        top: databaseType.toLowerCase() === 'mssql' ? astLimit : null,
-    };
-};
-exports.reportBuilderStateToAst = reportBuilderStateToAst;
-const astToReportBuilderState = (ast, databaseType, schema) => {
-    const tables = astFromToTables(ast.from);
-    const defaultTable = tables.length === 1 ? tables[0]?.name : undefined;
-    const columns = astColumnsToColumns(ast.columns, defaultTable);
-    const relevantColumns = tables.flatMap((table) => {
-        const schemaTable = schema.find((s) => s.name === table.name);
-        return schemaTable ? schemaTable.columns : [];
-    });
-    const pivot = astGroupByToPivot(ast.groupby, relevantColumns);
-    const sort = astOrderByToSort(ast.orderby);
-    const limit = astLimitToLimit(ast.limit);
-    const filterStack = (0, filterProcessing_1.generateFilterStack)((0, astFilterProcessing_1.astToFilterTree)(ast.where, databaseType.toLowerCase()));
-    return {
-        tables,
-        columns,
-        filterStack,
-        pivot,
-        sort,
-        limit,
-    };
-};
-exports.astToReportBuilderState = astToReportBuilderState;
-// Helper conversion functions
-const astColumnsToColumns = (node, defaultTable) => {
-    // expected
-    /*
-          [
-              {
-                  "expr": {
-                      "type": "column_ref",
-                      "table": null,
-                      "column": "field"
-                  },
-                  "as": null
-              },
-          ]
-          */
-    if (!node || !node.length || node.length === 0) {
-        return [];
-    }
-    return node.map((node) => {
-        return {
-            field: (0, astFilterProcessing_1.getFieldFromExpression)(node.expr),
-            table: node.expr.table ?? defaultTable ?? null,
-            alias: node.as ?? null,
-        };
-    });
-};
-const astGroupByToPivot = (node, columnInfo) => {
-    if (!node) {
-        return null;
-    }
-    return (0, convert_1.convertASTToPivotData)(node, columnInfo);
-};
-const astFromToTables = (node) => {
-    // expected
-    /*
-          [
-              {
-                  "db": null,
-                  "table": "all_tenant_data",
-                  "as": null,
-                  "join": 'INNER JOIN',
-              }
-          ]
-          */
-    if (!node) {
-        return [];
-    }
-    return node.map((_node) => {
-        return {
-            name: _node.table,
-            alias: _node.as ?? null,
-            join: _node.join
-                ? {
-                    type: _node.join,
-                    condition: {
-                        operator: _node.on.operator,
-                        left: {
-                            field: (0, astFilterProcessing_1.getFieldFromExpression)(_node.on.left.column.expr || _node.on.left.column),
-                            table: _node.on.left.table,
-                        },
-                        right: {
-                            field: (0, astFilterProcessing_1.getFieldFromExpression)(_node.on.right.column.expr || _node.on.right.column),
-                            table: _node.on.right.table,
-                        },
-                    },
-                }
-                : null,
-        };
-    });
-};
-const astOrderByToSort = (node) => {
-    // expected
-    /*
-          [
-              {
-                  "expr": {
-                      "type": "column_ref",
-                      "table": null,
-                      "column": "county_id"
-                  },
-                  "type": "DESC"
-              }
-          ]
-          */
-    if (!node) {
-        return [];
-    }
-    return node
-        .map((node) => {
-        return node.expr
-            ? {
-                field: (0, astFilterProcessing_1.getFieldFromExpression)(node.expr),
-                direction: node.type ?? 'ASC',
-            }
-            : null;
-    })
-        .filter((node) => node);
-};
-const astLimitToLimit = (node) => {
-    // expected
-    /*
-          {
-              "seperator": "",
-              "value": [
-                  {
-                      "type": "number",
-                      "value": 10
-                  }
-              ]
-          }
-          */
-    if (!node ||
-        !node.value ||
-        node.value.length === 0 ||
-        !node.value?.[0]?.value) {
-        return null;
-    }
-    return { value: node.value[0].value };
-};
-const createOperatorFromJoinCondition = (condition) => {
-    return {
-        type: 'binary_expr',
-        operator: condition.operator,
-        left: {
-            type: 'column_ref',
-            table: condition.left.table,
-            column: condition.left.field,
-        },
-        right: {
-            type: 'column_ref',
-            table: condition.right.table,
-            column: condition.right.field,
-        },
-    };
-};
-const tableToAstFrom = (tables) => {
-    return tables.map((table) => {
-        return {
-            db: null,
-            table: table.name,
-            as: table.alias ?? null,
-            join: table.join ? table.join.type : null,
-            on: table.join
-                ? createOperatorFromJoinCondition(table.join.condition)
-                : null,
-        };
-    });
-};
-const columnsToAstColumns = (columns) => {
-    if (!columns) {
-        return null;
-    }
-    return columns.map((column) => {
-        return {
-            expr: {
-                type: 'column_ref',
-                table: column.table ?? null,
-                column: column.field,
-            },
-            as: column.alias ?? null,
-        };
-    });
-};
-const sortToAstOrderBy = (sort) => {
-    if (!sort || sort.length === 0) {
-        return null;
-    }
-    return sort.map((sort) => {
-        return {
-            expr: {
-                type: 'column_ref',
-                table: null,
-                column: sort.field,
-            },
-            type: sort.direction,
-        };
-    });
-};
-const limitToAstLimit = (limit, databaseType) => {
-    if (!limit) {
-        return null;
-    }
-    if (databaseType.toLowerCase() === 'mssql') {
-        return {
-            value: limit.value,
-            percent: null,
-        };
-    }
-    return {
-        seperator: '',
-        value: [
-            {
-                type: 'number',
-                value: limit.value,
-            },
-        ],
-    };
-};
-// Validation
-const isValidPivotForReport = (pivot, uniqueValuesByColumn, reportColumns) => {
-    if (!(0, pivotProcessing_1.isValidPivot)(pivot).valid) {
-        return false;
-    }
-    // check that pivot rows and columns
-    const pivotColumns = reportColumns;
-    const possibleOptions = (0, pivotProcessing_1.getPossiblePivotFieldOptions)(pivotColumns, uniqueValuesByColumn);
-    if (pivot.rowField &&
-        pivot.columnField &&
-        pivot.rowField === pivot.columnField) {
-        return false;
-    }
-    if (pivot.rowField && !possibleOptions.rowFields.includes(pivot.rowField)) {
-        return false;
-    }
-    if (pivot.columnField &&
-        !possibleOptions.columnFields.includes(pivot.columnField)) {
-        return false;
-    }
-    for (const agg of pivot.aggregations ?? []) {
-        if (agg.valueField &&
-            !possibleOptions.valueFields.includes(agg.valueField)) {
-            return false;
-        }
-    }
-    if (!pivot.aggregations || pivot.aggregations.length === 0) {
-        return false;
-    }
-    return true;
-};
-exports.isValidPivotForReport = isValidPivotForReport;
-const makePivotValid = (pivot, uniqueValuesForPivot, reportColumns) => {
-    if (!pivot) {
-        return { pivot: null, hint: '' };
-    }
-    // try flipping row and column field
-    let newPivot = {
-        ...pivot,
-        rowField: pivot.columnField,
-        columnField: pivot.rowField,
-    };
-    if ((0, exports.isValidPivotForReport)(newPivot, uniqueValuesForPivot, reportColumns)) {
-        newPivot = (0, exports.setTypesOnPivot)(newPivot, reportColumns);
-        return {
-            pivot: newPivot,
-            hint: 'Flipping pivot row and column fields to maintain validity',
-        };
-    }
-    // try removing column field
-    newPivot = {
-        ...pivot,
-        rowField: pivot.rowField,
-        columnField: undefined,
-    };
-    if ((0, exports.isValidPivotForReport)(newPivot, uniqueValuesForPivot, reportColumns)) {
-        newPivot = (0, exports.setTypesOnPivot)(newPivot, reportColumns);
-        return {
-            pivot: newPivot,
-            hint: 'Removing column field to maintain validity',
-        };
-    }
-    return { pivot: null, hint: '' };
-};
-exports.makePivotValid = makePivotValid;
-const formatRows = (rows, columns, pivot, aggregationType, dateBucket) => {
-    const copiedRows = (0, util_1.deepCopy)(rows);
-    if (pivot) {
-        const formattedRows = copiedRows.map((row) => {
-            const formattedRow = row;
-            Object.keys(row).forEach((key) => {
-                const column = columns.find((c) => c.field === key);
-                let format = 'string';
-                if (!column) {
-                    format =
-                        aggregationType === 'count' ? 'whole_number' : 'two_decimal_places';
-                }
-                else {
-                    format = valueFormatter_1.DATE_FORMAT_TYPES.includes(column.format)
-                        ? dateBucket
-                            ? (0, dates_1.getDateFormatFromBucket)(dateBucket)
-                            : 'MMM_yyyy'
-                        : 'string';
-                }
-                const formattedValue = (0, valueFormatter_1.quillFormat)({
-                    value: row[key],
-                    format,
-                });
-                formattedRow[key] = formattedValue;
-            });
-            return formattedRow;
-        });
-        return formattedRows;
-    }
-    else {
-        const formattedRows = copiedRows.map((row) => {
-            return columns.reduce((formattedRow, column) => {
-                // Apply the format function to each field in the row
-                const formattedValue = (0, valueFormatter_1.quillFormat)({
-                    value: row[column.field],
-                    format: column.format,
-                });
-                formattedRow[column.field] = formattedValue;
-                return formattedRow;
-            }, {});
-        });
-        return formattedRows;
-    }
-};
-exports.formatRows = formatRows;
-const setTypesOnPivot = (newPivot, searchColumns) => ({
-    ...newPivot,
-    aggregations: newPivot.aggregations?.map((agg) => ({
-        ...agg,
-        valueFieldType: searchColumns.find((c) => c.field === agg.valueField)
-            ?.jsType,
-        valueField2Type: searchColumns.find((c) => c.field === agg.valueField2)
-            ?.jsType,
-    })),
-    valueField: newPivot.aggregations?.[0]?.valueField,
-    valueField2: newPivot.aggregations?.[0]?.valueField2,
-    aggregationType: newPivot.aggregations?.[0]?.aggregationType,
-    valueFieldType: searchColumns.find((c) => c.field === newPivot.aggregations?.[0]?.valueField)?.jsType,
-    valueField2Type: searchColumns.find((c) => c.field === newPivot.aggregations?.[0]?.valueField2)?.jsType,
-});
-exports.setTypesOnPivot = setTypesOnPivot;
-const orderTablesByBestPrimaryTable = (tables, foreignKeyMap) => {
-    const getPrimaryTableMappings = (table) => {
-        const tablesMappedByPrimaryTable = [{ ...table }];
-        foreignKeyMap[table.name]?.forEach((mapping) => {
-            if (tables.some((t) => t.name === mapping.foreignTable)) {
-                tablesMappedByPrimaryTable.push({
-                    name: mapping.foreignTable,
-                    join: {
-                        type: ReportBuilder_1.JoinType.INNER,
-                        condition: {
-                            operator: '=',
-                            left: { field: mapping.foreignKey, table: table.name },
-                            right: {
-                                field: mapping.foreignTablePrimaryKey,
-                                table: mapping.foreignTable,
-                            },
-                        },
-                    },
-                });
-            }
-        });
-        return tablesMappedByPrimaryTable;
-    };
-    if (tables.length === 0) {
-        return [];
-    }
-    let primaryTableMappings = [];
-    tables.forEach((table) => {
-        const mappedByTable = getPrimaryTableMappings(table);
-        if (mappedByTable.length > primaryTableMappings.length) {
-            primaryTableMappings = mappedByTable;
-        }
-    });
-    return primaryTableMappings;
-};
-exports.orderTablesByBestPrimaryTable = orderTablesByBestPrimaryTable;
-const validatedReportBuilderState = (state, foreignKeyMap) => {
-    let { tables, columns, filterStack, sort } = state;
-    const { pivot, limit } = state;
-    if (columns.length === 0) {
-        return {
-            tables: [],
-            columns: [],
-            filterStack: [],
-            pivot: null,
-            sort: [],
-            limit: null,
-        };
-    }
-    const tablesReferencedInColumns = tables.filter((table) => {
-        return columns.some((col) => col.table === table.name);
-    });
-    tables = columns.some((col) => col.table === tables[0]?.name)
-        ? tablesReferencedInColumns
-        : (0, exports.orderTablesByBestPrimaryTable)(tablesReferencedInColumns, foreignKeyMap);
-    columns = columns.filter((col) => {
-        return tables.some((table) => table.name === col.table);
-    });
-    filterStack = filterStack.filter((filter, index) => {
-        if (!filter.value) {
-            let prevFilterValid = true;
-            let nextFilterValid = true;
-            if (index === 1) {
-                const prevFilter = filterStack[0];
-                prevFilterValid =
-                    !!prevFilter.value &&
-                        columns.some((col) => col.field === prevFilter.value?.field) &&
-                        tables.some((table) => table.name === prevFilter.value?.table);
-            }
-            const nextFilter = filterStack[index + 1];
-            if (nextFilter) {
-                nextFilterValid =
-                    !!nextFilter.value &&
-                        columns.some((col) => col.field === nextFilter.value?.field) &&
-                        tables.some((table) => table.name === nextFilter.value?.table);
-            }
-            return prevFilterValid && nextFilterValid;
-        }
-        else {
-            return (columns.some((col) => col.field === filter.value?.field) &&
-                tables.some((table) => table.name === filter.value?.table));
-        }
-    });
-    sort = sort.filter((sort) => {
-        return columns.some((col) => (col.alias ?? col.field) === sort.field);
-    });
-    // If pivot is using removed columns, remove pivot
-    let removePivot = false;
-    if (pivot) {
-        const referencedColumns = [];
-        if (pivot.rowField) {
-            referencedColumns.push(pivot.rowField);
-        }
-        if (pivot.columnField) {
-            referencedColumns.push(pivot.columnField);
-        }
-        if (pivot.aggregations) {
-            pivot.aggregations.forEach((agg) => {
-                if (agg.valueField) {
-                    referencedColumns.push(agg.valueField);
-                }
-                if (agg.valueField2) {
-                    referencedColumns.push(agg.valueField2);
-                }
-            });
-        }
-        const columnMapping = referencedColumns
-            .map((col) => {
-            const column = columns.find((c) => (c.alias || c.field) === col);
-            return column;
-        })
-            .filter((c) => c !== undefined);
-        removePivot = !columnMapping.every((col) => columns.some((c) => (c.alias || c.field) === (col.alias || col.field) &&
-            c.table === col.table));
-    }
-    return {
-        tables,
-        columns,
-        filterStack,
-        pivot: removePivot ? null : pivot,
-        sort,
-        limit,
-    };
-};
-exports.validatedReportBuilderState = validatedReportBuilderState;

package/dist/cjs/utils/schema.d.ts

@@ -1,39 +0,0 @@
-import { ForeignKeyMap } from '../components/ReportBuilder/schema';
-import { QuillProviderClient } from '../models/Client';
-import { ColumnInternal } from '../models/Columns';
-import { CustomField } from '../models/Schema';
-import { Table } from '../models/Tables';
-import { EventTracking } from '../QuillProvider';
-export declare const getCustomFieldInfo: ({ client, tenants, abortSignal, getToken, eventTracking, }: {
-    client: QuillProviderClient;
-    tenants: {
-        tenantField: string;
-        tenantIds: (string | number)[];
-    }[] | (string | number)[];
-    abortSignal?: AbortSignal;
-    getToken: () => Promise<string>;
-    eventTracking: EventTracking | null;
-}) => Promise<{
-    [tableName: string]: CustomField[];
-} | null>;
-export declare const getSchemaInfo: ({ client, caller, tenants, tableIds, abortSignal, getToken, eventTracking, }: {
-    client: QuillProviderClient;
-    tenants?: {
-        tenantField: string;
-        tenantIds: (string | number)[];
-    }[] | (string | number)[];
-    caller?: string;
-    tableIds?: string[];
-    abortSignal?: AbortSignal;
-    getToken: () => Promise<string>;
-    eventTracking: EventTracking | null;
-}) => Promise<{
-    schemaData: Table[];
-    customFieldsByTable: {
-        [tableName: string]: CustomField[];
-    } | null;
-    schemaWithCustomFields: Table[];
-}>;
-export declare const customFieldToColumnInternal: (customField: CustomField) => ColumnInternal;
-export declare const getSchemaForeignKeyMapping: (schema: Table[]) => ForeignKeyMap;
-//# sourceMappingURL=schema.d.ts.map

package/dist/cjs/utils/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEd,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA+BjD,eAAO,MAAM,kBAAkB,GAAU,4DAMtC;IACD,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EACH;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,EAAE,GACzD,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;CACrC,KAAG,OAAO,CAAC;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAAA;CAAE,GAAG,IAAI,CA2FxD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,8EAQjC;IACD,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,CAAC,EACJ;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,EAAE,GACzD,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;CACrC,KAAG,OAAO,CAAC;IACV,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,mBAAmB,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;IACnE,sBAAsB,EAAE,KAAK,EAAE,CAAC;CACjC,CA0DA,CAAC;AA2BF,eAAO,MAAM,2BAA2B,GACtC,aAAa,WAAW,KACvB,cAaF,CAAC;AAIF,eAAO,MAAM,0BAA0B,GAAI,QAAQ,KAAK,EAAE,KAAG,aA8B5D,CAAC"}