@graphoria/server 0.1.0

package/dist/src/databases/high-level-operations.d.ts

@@ -0,0 +1,146 @@
+import type { RemoteRESTResolved } from "../remoteREST/types";
+import type { RemoteSchemaResolved } from "../remoteSchemas/types";
+import type { Auth, Database, MessageQueue, Operations, Permissions } from "../types/configuration";
+import type { ProcedureResolver, TableResolver } from "../types/db";
+/**
+ * High-level database operations that combine multiple lower-level operations
+ */
+export declare const getDatabasesStructure: (databases: Database[], auth?: Auth, fetchStructure?: (db: Database) => Promise<{
+    tables: {
+        dashedName: string;
+        dashedNameLS: string;
+        dottedName: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        entityType: "table" | "view";
+        columns: {
+            name: string;
+            dataType: string;
+            isNullable: boolean;
+            description: string | null;
+        }[];
+        foreignKeys: {
+            dashedName: string;
+            schema: string;
+            name: string;
+            columns: {
+                source: string;
+                target: string;
+            }[];
+        }[];
+        tableDescription?: string | null | undefined;
+    }[];
+    storedProcedures: {
+        dashedName: string;
+        dashedNameLS: string;
+        dottedName: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        parameters: {
+            name: string;
+            dataType: string | null;
+            maxLength: number;
+            precision: number;
+            scale: number;
+        }[];
+        signature?: string | undefined;
+        type?: string | undefined;
+    }[];
+}>) => Promise<{
+    tables: TableResolver[];
+    storedProcedures: {
+        db: {
+            name: string;
+            enabled: boolean;
+            type: "mssql" | "mysql" | "pg";
+            connection: {
+                host: string;
+                port: number;
+                user: string;
+                password: string;
+                database: string;
+            };
+            fieldNaming: string;
+            repository?: import("../config").CustomRepositoryFactory<import("../config").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("../config").DatabaseType> | undefined;
+            schema?: {
+                database: Record<string, {
+                    columns: {
+                        name: string;
+                        dataType: string;
+                        isNullable: boolean;
+                        description: string | null;
+                        virtual?: boolean | undefined;
+                        function?: string | undefined;
+                        params?: string[] | undefined;
+                        expression?: string | undefined;
+                    }[];
+                    relationships: {
+                        schema: string;
+                        name: string;
+                        columns: {
+                            source: string;
+                            target: string;
+                        }[];
+                    }[];
+                    columnDescriptions: Record<string, string>;
+                    description?: string | undefined;
+                }>;
+                excludedTables: string[];
+            } | undefined;
+            connectionOptions?: {
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+                maxLifetime: number;
+                tls: boolean;
+                prepare: boolean;
+                bigint: boolean;
+            } | {
+                pool: {
+                    max: number;
+                    min: number;
+                    idleTimeout: number;
+                };
+                connectionTimeout: number;
+                requestTimeout: number;
+                encrypt: boolean;
+                trustServerCertificate: boolean;
+                trustedConnection: boolean;
+                parseJSON: boolean;
+            } | undefined;
+        };
+        internalName: string;
+        resolverName: string;
+        dottedName: string;
+        dashedName: string;
+        dashedNameLS: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        parameters: {
+            name: string;
+            dataType: string | null;
+            maxLength: number;
+            precision: number;
+            scale: number;
+        }[];
+        signature?: string | undefined;
+        type?: string | undefined;
+    }[];
+}>;
+export type EntitiesOfRole = {
+    tables: TableResolver[];
+    storedProcedures: ProcedureResolver[];
+    queues: MessageQueue[];
+    operations: Operations;
+    remoteSchemas: RemoteSchemaResolved[];
+    remoteREST: RemoteRESTResolved[];
+};
+export declare const sourcesForEachRole: (tables: TableResolver[], storedProcedures: ProcedureResolver[], queues: MessageQueue[], operations: Operations, permissionsMapping?: Permissions, remoteSchemas?: RemoteSchemaResolved[], remoteREST?: RemoteRESTResolved[]) => Record<string, EntitiesOfRole>;
+//# sourceMappingURL=high-level-operations.d.ts.map

package/dist/src/databases/high-level-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"high-level-operations.d.ts","sourceRoot":"","sources":["../../../src/databases/high-level-operations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EACV,IAAI,EACJ,QAAQ,EACR,YAAY,EACZ,UAAU,EACV,WAAW,EAGZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAU,iBAAiB,EAAE,aAAa,EAAU,MAAM,aAAa,CAAC;AAMpF;;GAEG;AAEH,eAAO,MAAM,qBAAqB,GAChC,WAAW,QAAQ,EAAE,EACrB,OAAO,IAAI,EACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGtC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,gBAAgB,EAAE,iBAAiB,EAAE,CAAC;IACtC,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,oBAAoB,EAAE,CAAC;IACtC,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC,CAAC;AAmCF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,aAAa,EAAE,EACvB,kBAAkB,iBAAiB,EAAE,EACrC,QAAQ,YAAY,EAAE,EACtB,YAAY,UAAU,EACtB,qBAAoB,WAAgB,EACpC,gBAAe,oBAAoB,EAAO,EAC1C,aAAY,kBAAkB,EAAO,mCA4FpC,CAAC"}

package/dist/src/databases/high-level-operations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=high-level-operations.test.d.ts.map

package/dist/src/databases/high-level-operations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"high-level-operations.test.d.ts","sourceRoot":"","sources":["../../../src/databases/high-level-operations.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/index.d.ts

@@ -0,0 +1,8 @@
+export { executeQuery, executeQueryJSON, callStoredProcedure } from "./core/executor";
+export { generateSQL } from "./core/query-builder";
+export { databaseAdapters } from "./core/function-mapping";
+export { getDatabaseStructure, getViewsFromDB } from "./metadata/structure";
+export { createAuthTables, getLoginFn, checkUserCredentials, insertAuthUser, verifyAuthTablesExist, } from "./auth/auth-operations";
+export { buildRelationshipResolver, buildTableResolver, buildProcedureResolver, } from "./transformers/data-transformers";
+export { getDatabasesStructure, sourcesForEachRole } from "./high-level-operations";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/databases/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/databases/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtF,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG5E,OAAO,EACL,gBAAgB,EAChB,UAAU,EACV,oBAAoB,EACpB,cAAc,EACd,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/src/databases/metadata/structure.d.ts

@@ -0,0 +1,56 @@
+import type { Database } from "../../types/configuration";
+/**
+ * Database metadata and structure retrieval functions
+ */
+export declare const getDatabaseStructure: (db: Database) => Promise<{
+    tables: {
+        dashedName: string;
+        dashedNameLS: string;
+        dottedName: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        entityType: "table" | "view";
+        columns: {
+            name: string;
+            dataType: string;
+            isNullable: boolean;
+            description: string | null;
+        }[];
+        foreignKeys: {
+            dashedName: string;
+            schema: string;
+            name: string;
+            columns: {
+                source: string;
+                target: string;
+            }[];
+        }[];
+        tableDescription?: string | null | undefined;
+    }[];
+    storedProcedures: {
+        dashedName: string;
+        dashedNameLS: string;
+        dottedName: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        parameters: {
+            name: string;
+            dataType: string | null;
+            maxLength: number;
+            precision: number;
+            scale: number;
+        }[];
+        signature?: string | undefined;
+        type?: string | undefined;
+    }[];
+}>;
+export declare const getViewsFromDB: (db: Database) => Promise<{
+    schema: string;
+    name: string;
+    definition: string;
+}[]>;
+//# sourceMappingURL=structure.d.ts.map

package/dist/src/databases/metadata/structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../../../../src/databases/metadata/structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAI1D;;GAEG;AAEH,eAAO,MAAM,oBAAoB,GAAU,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACH,CAAC;AAErD,eAAO,MAAM,cAAc,GAAU,IAAI,QAAQ;;;;IAA2C,CAAC"}

package/dist/src/databases/schemaBuilder/convert.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=convert.d.ts.map

package/dist/src/databases/schemaBuilder/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../../../src/databases/schemaBuilder/convert.ts"],"names":[],"mappings":""}

package/dist/src/databases/schemaBuilder/generateCreateTable/index.d.ts

@@ -0,0 +1,15 @@
+import type { Database, DatabaseType } from "../../../types/configuration";
+import type { TableResolver, Tables } from "../../../types/db";
+export type GenerateCreateTableSQLParameters = {
+    schemaCreation?: boolean;
+    schemaCreationIfExists?: boolean;
+    tableCreationIfExists?: boolean;
+};
+export declare const generateCreateTableSQL: (toDb: DatabaseType) => (table: TableResolver, { schemaCreation, schemaCreationIfExists, tableCreationIfExists, }?: GenerateCreateTableSQLParameters) => string;
+export type GenerateCreateTableSQL = ReturnType<typeof generateCreateTableSQL>;
+export declare const generateCreateTableMSSQL: (table: TableResolver, { schemaCreation, schemaCreationIfExists, tableCreationIfExists, }?: GenerateCreateTableSQLParameters) => string;
+export declare const generateCreateTablePostgreSQL: (table: TableResolver, { schemaCreation, schemaCreationIfExists, tableCreationIfExists, }?: GenerateCreateTableSQLParameters) => string;
+export declare const generateCreateTableMySQL: (table: TableResolver, { schemaCreation, schemaCreationIfExists, tableCreationIfExists, }?: GenerateCreateTableSQLParameters) => string;
+export declare const generateCreateTablesSQL: (db: Database, tables: Tables, options?: GenerateCreateTableSQLParameters) => string;
+export type GenerateCreateTablesSQL = typeof generateCreateTablesSQL;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/databases/schemaBuilder/generateCreateTable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateCreateTable/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AA0C/D,MAAM,MAAM,gCAAgC,GAAG;IAC7C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAChC,MAAM,YAAY,MAEjB,OAAO,aAAa,EACpB,qEAIG,gCAAqC,WA0CzC,CAAC;AAEJ,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE/E,eAAO,MAAM,wBAAwB,UAnD1B,aAAa,uEAKjB,gCAAgC,WA8CgC,CAAC;AACxE,eAAO,MAAM,6BAA6B,UApD/B,aAAa,uEAKjB,gCAAgC,WA+CkC,CAAC;AAC1E,eAAO,MAAM,wBAAwB,UArD1B,aAAa,uEAKjB,gCAAgC,WAgDgC,CAAC;AAExE,eAAO,MAAM,uBAAuB,GAClC,IAAI,QAAQ,EACZ,QAAQ,MAAM,EACd,UAAU,gCAAgC,WAkB3C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC"}

package/dist/src/databases/schemaBuilder/generateCreateTable/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/databases/schemaBuilder/generateCreateTable/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateCreateTable/index.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/schemaBuilder/generateCreateView/index.d.ts

@@ -0,0 +1,18 @@
+import type { DatabaseType } from "../../../types/configuration";
+import type { View } from "../../../types/db";
+export type GenerateCreateViewSQLParameters = {
+    schemaCreation?: boolean;
+    schemaCreationIfExists?: boolean;
+    viewCreationIfExists?: boolean;
+    replaceExisting?: boolean;
+};
+export declare const generateCreateViewSQL: (toDb: DatabaseType) => (view: View, { schemaCreation, schemaCreationIfExists, viewCreationIfExists, replaceExisting, }?: GenerateCreateViewSQLParameters) => string;
+export type GenerateCreateViewSQL = ReturnType<typeof generateCreateViewSQL>;
+export declare const generateCreateViewMSSQL: (view: View, { schemaCreation, schemaCreationIfExists, viewCreationIfExists, replaceExisting, }?: GenerateCreateViewSQLParameters) => string;
+export declare const generateCreateViewPostgreSQL: (view: View, { schemaCreation, schemaCreationIfExists, viewCreationIfExists, replaceExisting, }?: GenerateCreateViewSQLParameters) => string;
+export declare const generateCreateViewsSQL: (dbType: DatabaseType) => (views: View[], options?: GenerateCreateViewSQLParameters) => string;
+export type GenerateCreateViewsSQL = ReturnType<typeof generateCreateViewsSQL>;
+export declare const generateCreateViewsMSSQL: (views: View[], options?: GenerateCreateViewSQLParameters) => string;
+export declare const generateCreateViewsPostgreSQL: (views: View[], options?: GenerateCreateViewSQLParameters) => string;
+export declare const generateCreateViewsMySQL: (views: View[], options?: GenerateCreateViewSQLParameters) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/databases/schemaBuilder/generateCreateView/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateCreateView/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAM9C,MAAM,MAAM,+BAA+B,GAAG;IAC5C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAaF,eAAO,MAAM,qBAAqB,GAC/B,MAAM,YAAY,MAEjB,MAAM,IAAI,EACV,qFAKG,+BAAoC,WAoCxC,CAAC;AAEJ,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE7E,eAAO,MAAM,uBAAuB,SA9C1B,IAAI,uFAMP,+BAA+B,WAwC+B,CAAC;AACtE,eAAO,MAAM,4BAA4B,SA/C/B,IAAI,uFAMP,+BAA+B,WAyCiC,CAAC;AAExE,eAAO,MAAM,sBAAsB,GAChC,QAAQ,YAAY,MAAM,OAAO,IAAI,EAAE,EAAE,UAAU,+BAA+B,WAgBlF,CAAC;AAEJ,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE/E,eAAO,MAAM,wBAAwB,UApBD,IAAI,EAAE,YAAY,+BAA+B,WAoBd,CAAC;AACxE,eAAO,MAAM,6BAA6B,UArBN,IAAI,EAAE,YAAY,+BAA+B,WAqBZ,CAAC;AAC1E,eAAO,MAAM,wBAAwB,UAtBD,IAAI,EAAE,YAAY,+BAA+B,WAsBd,CAAC"}

package/dist/src/databases/schemaBuilder/generateInsert/index.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseType } from "../../../types/configuration";
+import type { TableResolver } from "../../../types/db";
+export declare const generateInsertSQL: (toDb: DatabaseType) => (table: TableResolver, data: Record<string, any>[]) => string;
+export type GenerateInsertSQL = ReturnType<typeof generateInsertSQL>;
+export declare const generateInsertSQLMSSQL: (table: TableResolver, data: Record<string, any>[]) => string;
+export declare const generateInsertSQLPostgreSQL: (table: TableResolver, data: Record<string, any>[]) => string;
+export declare const generateInsertSQLMySQL: (table: TableResolver, data: Record<string, any>[]) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/databases/schemaBuilder/generateInsert/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateInsert/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,eAAO,MAAM,iBAAiB,GAC3B,MAAM,YAAY,MAElB,OAAO,aAAa,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAkCjD,CAAC;AAEJ,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAErE,eAAO,MAAM,sBAAsB,UAtCzB,aAAa,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAsCY,CAAC;AACjE,eAAO,MAAM,2BAA2B,UAvC9B,aAAa,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAuCc,CAAC;AACnE,eAAO,MAAM,sBAAsB,UAxCzB,aAAa,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAwCY,CAAC"}

package/dist/src/databases/schemaBuilder/generateInsert/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/databases/schemaBuilder/generateInsert/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateInsert/index.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/schemaBuilder/generateSchemaCreation/index.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseType } from "../../../types/configuration";
+export declare const generateSchemaCreationSQL: (toDb: DatabaseType) => (schema: string, schemaCreationIfExists?: boolean) => string;
+export type GenerateSchemaCreationSQL = ReturnType<typeof generateSchemaCreationSQL>;
+export declare const generateSchemaCreationMSSQL: (schema: string, schemaCreationIfExists?: boolean) => string;
+export declare const generateSchemaCreationPostgreSQL: (schema: string, schemaCreationIfExists?: boolean) => string;
+export declare const generateSchemaCreationMySQL: (schema: string, schemaCreationIfExists?: boolean) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/databases/schemaBuilder/generateSchemaCreation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateSchemaCreation/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,eAAO,MAAM,yBAAyB,GACnC,MAAM,YAAY,MAClB,QAAQ,MAAM,EAAE,gCAA6B,WAkB7C,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAErF,eAAO,MAAM,2BAA2B,WAtB7B,MAAM,6CAsB4D,CAAC;AAC9E,eAAO,MAAM,gCAAgC,WAvBlC,MAAM,6CAuB8D,CAAC;AAChF,eAAO,MAAM,2BAA2B,WAxB7B,MAAM,6CAwB4D,CAAC"}

package/dist/src/databases/schemaBuilder/generateSchemaCreation/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/databases/schemaBuilder/generateSchemaCreation/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/generateSchemaCreation/index.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/schemaBuilder/mssqlToPostgres/convertView.d.ts

@@ -0,0 +1,2 @@
+export declare const convertMSSQLViewToPostgres: (viewDefinition: string) => string;
+//# sourceMappingURL=convertView.d.ts.map

package/dist/src/databases/schemaBuilder/mssqlToPostgres/convertView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertView.d.ts","sourceRoot":"","sources":["../../../../../src/databases/schemaBuilder/mssqlToPostgres/convertView.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,GAAI,gBAAgB,MAAM,KAAG,MA8CnE,CAAC"}

package/dist/src/databases/schemaBuilder/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const splitInternalName: (internalName: string, helpers?: boolean) => {
+    nameDashed?: string | undefined;
+    nameDotted?: string | undefined;
+    nameDottedQuoted?: string | undefined;
+    schema: string;
+    name: string;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/databases/schemaBuilder/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/databases/schemaBuilder/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,GAAI,cAAc,MAAM,EAAE,UAAS,OAAe;;;;;;CAgB/E,CAAC"}

package/dist/src/databases/sqlTypeUtils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Utility functions for SQL data type categorization and mapping
+ * Supports MSSQL, MySQL, and PostgreSQL data types
+ */
+export declare enum SqlTypeCategory {
+    INTEGER = "INTEGER",
+    FLOAT = "FLOAT",
+    BOOLEAN = "BOOLEAN",
+    DATE_TIME = "DATE_TIME",
+    STRING = "STRING"
+}
+/**
+ * Categorizes a SQL data type into one of the standard categories
+ * @param dataType - The SQL data type to categorize (case-insensitive)
+ * @returns The category of the data type
+ */
+export declare const categorizeSqlType: (dataType: string) => SqlTypeCategory;
+/**
+ * Checks if a SQL data type is numeric (integer or floating-point)
+ * @param dataType - The SQL data type to check
+ * @returns True if the type is numeric, false otherwise
+ */
+export declare const isNumericType: (dataType: string) => boolean;
+//# sourceMappingURL=sqlTypeUtils.d.ts.map

package/dist/src/databases/sqlTypeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlTypeUtils.d.ts","sourceRoot":"","sources":["../../../src/databases/sqlTypeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,eA8DpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,KAAG,OAGhD,CAAC"}

package/dist/src/databases/sqlTypeUtils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sqlTypeUtils.test.d.ts.map

package/dist/src/databases/sqlTypeUtils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlTypeUtils.test.d.ts","sourceRoot":"","sources":["../../../src/databases/sqlTypeUtils.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/transformers/data-transformers.d.ts

@@ -0,0 +1,215 @@
+import type { Database, Relationships } from "../../types/configuration";
+import type { StoredProcedure, Table, Tables } from "../../types/db";
+/**
+ * Data transformation functions for converting database objects to internal formats
+ */
+export declare const buildRelationshipResolver: (table: Table, foreignKey: Relationships[number], db: Database, reversed?: boolean) => {
+    internalName: string;
+    fromInternalName: string;
+    toInternalName: string;
+    fromResolverName: string;
+    toResolverName: string;
+    schema: string;
+    name: string;
+    columns: {
+        source: string;
+        target: string;
+    }[];
+};
+export declare const buildTableResolver: (tables: Tables, table: Table, db: Database) => {
+    db: {
+        name: string;
+        enabled: boolean;
+        type: "mssql" | "mysql" | "pg";
+        connection: {
+            host: string;
+            port: number;
+            user: string;
+            password: string;
+            database: string;
+        };
+        fieldNaming: string;
+        repository?: import("../../config").CustomRepositoryFactory<import("../../config").DatabaseType> | undefined;
+        onConnect?: import("../../config").OnConnectHandler<import("../../config").DatabaseType> | undefined;
+        schema?: {
+            database: Record<string, {
+                columns: {
+                    name: string;
+                    dataType: string;
+                    isNullable: boolean;
+                    description: string | null;
+                    virtual?: boolean | undefined;
+                    function?: string | undefined;
+                    params?: string[] | undefined;
+                    expression?: string | undefined;
+                }[];
+                relationships: {
+                    schema: string;
+                    name: string;
+                    columns: {
+                        source: string;
+                        target: string;
+                    }[];
+                }[];
+                columnDescriptions: Record<string, string>;
+                description?: string | undefined;
+            }>;
+            excludedTables: string[];
+        } | undefined;
+        connectionOptions?: {
+            max: number;
+            idleTimeout: number;
+            connectionTimeout: number;
+            maxLifetime: number;
+            tls: boolean;
+            prepare: boolean;
+            bigint: boolean;
+        } | {
+            pool: {
+                max: number;
+                min: number;
+                idleTimeout: number;
+            };
+            connectionTimeout: number;
+            requestTimeout: number;
+            encrypt: boolean;
+            trustServerCertificate: boolean;
+            trustedConnection: boolean;
+            parseJSON: boolean;
+        } | undefined;
+    };
+    internalName: string;
+    resolverName: string;
+    relationships: {
+        internalName: string;
+        fromInternalName: string;
+        toInternalName: string;
+        fromResolverName: string;
+        toResolverName: string;
+        schema: string;
+        name: string;
+        columns: {
+            source: string;
+            target: string;
+        }[];
+    }[];
+    relationshipsReversed: {
+        internalName: string;
+        fromInternalName: string;
+        toInternalName: string;
+        fromResolverName: string;
+        toResolverName: string;
+        schema: string;
+        name: string;
+        columns: {
+            source: string;
+            target: string;
+        }[];
+    }[];
+    dashedName: string;
+    dashedNameLS: string;
+    dottedName: string;
+    dottedQuotedName: string;
+    schemaName: string;
+    schema: string;
+    name: string;
+    entityType: "table" | "view";
+    columns: {
+        name: string;
+        dataType: string;
+        isNullable: boolean;
+        description: string | null;
+    }[];
+    foreignKeys: {
+        dashedName: string;
+        schema: string;
+        name: string;
+        columns: {
+            source: string;
+            target: string;
+        }[];
+    }[];
+    tableDescription?: string | null | undefined;
+};
+export declare const buildProcedureResolver: (sp: StoredProcedure, db: Database) => {
+    db: {
+        name: string;
+        enabled: boolean;
+        type: "mssql" | "mysql" | "pg";
+        connection: {
+            host: string;
+            port: number;
+            user: string;
+            password: string;
+            database: string;
+        };
+        fieldNaming: string;
+        repository?: import("../../config").CustomRepositoryFactory<import("../../config").DatabaseType> | undefined;
+        onConnect?: import("../../config").OnConnectHandler<import("../../config").DatabaseType> | undefined;
+        schema?: {
+            database: Record<string, {
+                columns: {
+                    name: string;
+                    dataType: string;
+                    isNullable: boolean;
+                    description: string | null;
+                    virtual?: boolean | undefined;
+                    function?: string | undefined;
+                    params?: string[] | undefined;
+                    expression?: string | undefined;
+                }[];
+                relationships: {
+                    schema: string;
+                    name: string;
+                    columns: {
+                        source: string;
+                        target: string;
+                    }[];
+                }[];
+                columnDescriptions: Record<string, string>;
+                description?: string | undefined;
+            }>;
+            excludedTables: string[];
+        } | undefined;
+        connectionOptions?: {
+            max: number;
+            idleTimeout: number;
+            connectionTimeout: number;
+            maxLifetime: number;
+            tls: boolean;
+            prepare: boolean;
+            bigint: boolean;
+        } | {
+            pool: {
+                max: number;
+                min: number;
+                idleTimeout: number;
+            };
+            connectionTimeout: number;
+            requestTimeout: number;
+            encrypt: boolean;
+            trustServerCertificate: boolean;
+            trustedConnection: boolean;
+            parseJSON: boolean;
+        } | undefined;
+    };
+    internalName: string;
+    resolverName: string;
+    dottedName: string;
+    dashedName: string;
+    dashedNameLS: string;
+    dottedQuotedName: string;
+    schemaName: string;
+    schema: string;
+    name: string;
+    parameters: {
+        name: string;
+        dataType: string | null;
+        maxLength: number;
+        precision: number;
+        scale: number;
+    }[];
+    signature?: string | undefined;
+    type?: string | undefined;
+};
+//# sourceMappingURL=data-transformers.d.ts.map

package/dist/src/databases/transformers/data-transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transformers.d.ts","sourceRoot":"","sources":["../../../../src/databases/transformers/data-transformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACzE,OAAO,KAAK,EAAwB,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI3F;;GAEG;AAEH,eAAO,MAAM,yBAAyB,GACpC,OAAO,KAAK,EACZ,YAAY,aAAa,CAAC,MAAM,CAAC,EACjC,IAAI,QAAQ,EACZ,kBAAgB;;;;;;;;;;;;CAgEjB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,EAAE,OAAO,KAAK,EAAE,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B5E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,IAAI,eAAe,EAAE,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAevE,CAAC"}

package/dist/src/databases/transformers/data-transformers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-transformers.test.d.ts.map

package/dist/src/databases/transformers/data-transformers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transformers.test.d.ts","sourceRoot":"","sources":["../../../../src/databases/transformers/data-transformers.test.ts"],"names":[],"mappings":""}

package/dist/src/databases/transformers/genResolverName.d.ts

@@ -0,0 +1,2 @@
+export declare const genResolverName: (schema: string, name: string, type: "table" | "view" | "sp", fieldNaming?: string, dbName?: string, suffix?: string) => string;
+//# sourceMappingURL=genResolverName.d.ts.map

package/dist/src/databases/transformers/genResolverName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genResolverName.d.ts","sourceRoot":"","sources":["../../../../src/databases/transformers/genResolverName.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,MAAM,OAAO,GAAG,MAAM,GAAG,IAAI,EAC7B,cAAa,MAA0B,EACvC,SAAQ,MAAW,EACnB,SAAS,MAAM,WAWhB,CAAC"}

package/dist/src/databases/transformers/genResolverName.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=genResolverName.test.d.ts.map

package/dist/src/databases/transformers/genResolverName.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genResolverName.test.d.ts","sourceRoot":"","sources":["../../../../src/databases/transformers/genResolverName.test.ts"],"names":[],"mappings":""}