@frictionless-ts/database 1.0.1

package/build/plugin.spec.js

@@ -0,0 +1,328 @@
+import * as pl from "nodejs-polars";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as packageModule from "./package/index.js";
+import { DatabasePlugin } from "./plugin.js";
+import * as schemaModule from "./schema/index.js";
+import * as tableModule from "./table/index.js";
+vi.mock("./package/index.ts", () => ({
+    loadPackageFromDatabase: vi.fn(),
+    savePackageToDatabase: vi.fn(),
+}));
+vi.mock("./table/index.ts", () => ({
+    loadDatabaseTable: vi.fn(),
+    saveDatabaseTable: vi.fn(),
+}));
+vi.mock("./schema/index.ts", () => ({
+    inferDatabaseSchema: vi.fn(),
+}));
+describe("DatabasePlugin", () => {
+    let plugin;
+    let mockLoadPackageFromDatabase;
+    let mockSavePackageToDatabase;
+    let mockLoadDatabaseTable;
+    let mockSaveDatabaseTable;
+    let mockInferDatabaseSchema;
+    beforeEach(() => {
+        plugin = new DatabasePlugin();
+        mockLoadPackageFromDatabase = vi.mocked(packageModule.loadPackageFromDatabase);
+        mockSavePackageToDatabase = vi.mocked(packageModule.savePackageToDatabase);
+        mockLoadDatabaseTable = vi.mocked(tableModule.loadDatabaseTable);
+        mockSaveDatabaseTable = vi.mocked(tableModule.saveDatabaseTable);
+        mockInferDatabaseSchema = vi.mocked(schemaModule.inferDatabaseSchema);
+        vi.clearAllMocks();
+    });
+    describe("loadPackage", () => {
+        it("should load package from postgresql database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromDatabase.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("postgresql://localhost/testdb");
+            expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith("postgresql://localhost/testdb", { format: "postgresql" });
+            expect(result).toEqual(mockPackage);
+        });
+        it("should load package from mysql database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromDatabase.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("mysql://localhost/testdb");
+            expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith("mysql://localhost/testdb", { format: "mysql" });
+            expect(result).toEqual(mockPackage);
+        });
+        it("should load package from sqlite database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromDatabase.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("sqlite://test.db");
+            expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith("sqlite://test.db", {
+                format: "sqlite",
+            });
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for non-database sources", async () => {
+            const result = await plugin.loadPackage("test.csv");
+            expect(mockLoadPackageFromDatabase).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for http urls", async () => {
+            const result = await plugin.loadPackage("https://example.com/data");
+            expect(mockLoadPackageFromDatabase).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("savePackage", () => {
+        it("should save package to postgresql database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockSavePackageToDatabase.mockResolvedValue(undefined);
+            await plugin.savePackage(mockPackage, {
+                target: "postgresql://localhost/testdb",
+            });
+            expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {
+                target: "postgresql://localhost/testdb",
+                format: "postgresql",
+            });
+        });
+        it("should save package to mysql database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockSavePackageToDatabase.mockResolvedValue(undefined);
+            await plugin.savePackage(mockPackage, {
+                target: "mysql://localhost/testdb",
+            });
+            expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {
+                target: "mysql://localhost/testdb",
+                format: "mysql",
+            });
+        });
+        it("should save package to sqlite database", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockSavePackageToDatabase.mockResolvedValue(undefined);
+            await plugin.savePackage(mockPackage, { target: "sqlite://test.db" });
+            expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {
+                target: "sqlite://test.db",
+                format: "sqlite",
+            });
+        });
+        it("should return undefined for non-database targets", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            const result = await plugin.savePackage(mockPackage, {
+                target: "test.csv",
+            });
+            expect(mockSavePackageToDatabase).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should pass through plugins option", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            const mockPlugins = [];
+            mockSavePackageToDatabase.mockResolvedValue(undefined);
+            await plugin.savePackage(mockPackage, {
+                target: "sqlite://test.db",
+                plugins: mockPlugins,
+            });
+            expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {
+                target: "sqlite://test.db",
+                format: "sqlite",
+                plugins: mockPlugins,
+            });
+        });
+    });
+    describe("loadTable", () => {
+        it("should load table from postgresql resource", async () => {
+            const resource = {
+                path: "postgresql://localhost/testdb",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadDatabaseTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadDatabaseTable).toHaveBeenCalledWith({
+                ...resource,
+                format: "postgresql",
+            });
+            expect(result).toEqual(mockTable);
+        });
+        it("should load table from mysql resource", async () => {
+            const resource = {
+                path: "mysql://localhost/testdb",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadDatabaseTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadDatabaseTable).toHaveBeenCalledWith({
+                ...resource,
+                format: "mysql",
+            });
+            expect(result).toEqual(mockTable);
+        });
+        it("should load table from sqlite resource", async () => {
+            const resource = {
+                path: "sqlite://test.db",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadDatabaseTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadDatabaseTable).toHaveBeenCalledWith({
+                ...resource,
+                format: "sqlite",
+            });
+            expect(result).toEqual(mockTable);
+        });
+        it("should return undefined for non-database resources", async () => {
+            const resource = {
+                path: "test.csv",
+            };
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadDatabaseTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle explicit format specification", async () => {
+            const resource = {
+                path: "test.txt",
+                format: "sqlite",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadDatabaseTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadDatabaseTable).toHaveBeenCalledWith({
+                ...resource,
+                format: "sqlite",
+            });
+            expect(result).toEqual(mockTable);
+        });
+    });
+    describe("saveTable", () => {
+        it("should save table to postgresql database", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "postgresql://localhost/testdb" };
+            mockSaveDatabaseTable.mockResolvedValue("postgresql://localhost/testdb");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {
+                ...options,
+                format: "postgresql",
+            });
+            expect(result).toBe("postgresql://localhost/testdb");
+        });
+        it("should save table to mysql database", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "mysql://localhost/testdb" };
+            mockSaveDatabaseTable.mockResolvedValue("mysql://localhost/testdb");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {
+                ...options,
+                format: "mysql",
+            });
+            expect(result).toBe("mysql://localhost/testdb");
+        });
+        it("should save table to sqlite database", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "sqlite://test.db" };
+            mockSaveDatabaseTable.mockResolvedValue("sqlite://test.db");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {
+                ...options,
+                format: "sqlite",
+            });
+            expect(result).toBe("sqlite://test.db");
+        });
+        it("should return undefined for non-database paths", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.csv" };
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveDatabaseTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle explicit format specification", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "test.txt", format: "sqlite" };
+            mockSaveDatabaseTable.mockResolvedValue("test.txt");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {
+                ...options,
+                format: "sqlite",
+            });
+            expect(result).toBe("test.txt");
+        });
+    });
+    describe("inferSchema", () => {
+        it("should infer schema for postgresql resource", async () => {
+            const resource = {
+                path: "postgresql://localhost/testdb",
+            };
+            const mockSchema = { fields: [] };
+            mockInferDatabaseSchema.mockResolvedValue(mockSchema);
+            const result = await plugin.inferSchema(resource);
+            expect(mockInferDatabaseSchema).toHaveBeenCalledWith({
+                ...resource,
+                format: "postgresql",
+            });
+            expect(result).toEqual(mockSchema);
+        });
+        it("should infer schema for mysql resource", async () => {
+            const resource = {
+                path: "mysql://localhost/testdb",
+            };
+            const mockSchema = { fields: [] };
+            mockInferDatabaseSchema.mockResolvedValue(mockSchema);
+            const result = await plugin.inferSchema(resource);
+            expect(mockInferDatabaseSchema).toHaveBeenCalledWith({
+                ...resource,
+                format: "mysql",
+            });
+            expect(result).toEqual(mockSchema);
+        });
+        it("should infer schema for sqlite resource", async () => {
+            const resource = {
+                path: "sqlite://test.db",
+            };
+            const mockSchema = { fields: [] };
+            mockInferDatabaseSchema.mockResolvedValue(mockSchema);
+            const result = await plugin.inferSchema(resource);
+            expect(mockInferDatabaseSchema).toHaveBeenCalledWith({
+                ...resource,
+                format: "sqlite",
+            });
+            expect(result).toEqual(mockSchema);
+        });
+        it("should return undefined for non-database resources", async () => {
+            const resource = {
+                path: "test.csv",
+            };
+            const result = await plugin.inferSchema(resource);
+            expect(mockInferDatabaseSchema).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle explicit format specification", async () => {
+            const resource = {
+                path: "test.txt",
+                format: "sqlite",
+            };
+            const mockSchema = { fields: [] };
+            mockInferDatabaseSchema.mockResolvedValue(mockSchema);
+            const result = await plugin.inferSchema(resource);
+            expect(mockInferDatabaseSchema).toHaveBeenCalledWith({
+                ...resource,
+                format: "sqlite",
+            });
+            expect(result).toEqual(mockSchema);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.spec.js","sourceRoot":"","sources":["../plugin.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Package, Resource } from \"@frictionless-ts/metadata\"\nimport * as pl from \"nodejs-polars\"\nimport { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport * as packageModule from \"./package/index.ts\"\nimport { DatabasePlugin } from \"./plugin.ts\"\nimport * as schemaModule from \"./schema/index.ts\"\nimport * as tableModule from \"./table/index.ts\"\n\nvi.mock(\"./package/index.ts\", () => ({\n  loadPackageFromDatabase: vi.fn(),\n  savePackageToDatabase: vi.fn(),\n}))\n\nvi.mock(\"./table/index.ts\", () => ({\n  loadDatabaseTable: vi.fn(),\n  saveDatabaseTable: vi.fn(),\n}))\n\nvi.mock(\"./schema/index.ts\", () => ({\n  inferDatabaseSchema: vi.fn(),\n}))\n\ndescribe(\"DatabasePlugin\", () => {\n  let plugin: DatabasePlugin\n  let mockLoadPackageFromDatabase: ReturnType<typeof vi.fn>\n  let mockSavePackageToDatabase: ReturnType<typeof vi.fn>\n  let mockLoadDatabaseTable: ReturnType<typeof vi.fn>\n  let mockSaveDatabaseTable: ReturnType<typeof vi.fn>\n  let mockInferDatabaseSchema: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    plugin = new DatabasePlugin()\n    mockLoadPackageFromDatabase = vi.mocked(\n      packageModule.loadPackageFromDatabase,\n    )\n    mockSavePackageToDatabase = vi.mocked(packageModule.savePackageToDatabase)\n    mockLoadDatabaseTable = vi.mocked(tableModule.loadDatabaseTable)\n    mockSaveDatabaseTable = vi.mocked(tableModule.saveDatabaseTable)\n    mockInferDatabaseSchema = vi.mocked(schemaModule.inferDatabaseSchema)\n    vi.clearAllMocks()\n  })\n\n  describe(\"loadPackage\", () => {\n    it(\"should load package from postgresql database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromDatabase.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"postgresql://localhost/testdb\")\n\n      expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith(\n        \"postgresql://localhost/testdb\",\n        { format: \"postgresql\" },\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should load package from mysql database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromDatabase.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"mysql://localhost/testdb\")\n\n      expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith(\n        \"mysql://localhost/testdb\",\n        { format: \"mysql\" },\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should load package from sqlite database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromDatabase.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\"sqlite://test.db\")\n\n      expect(mockLoadPackageFromDatabase).toHaveBeenCalledWith(\n        \"sqlite://test.db\",\n        {\n          format: \"sqlite\",\n        },\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should return undefined for non-database sources\", async () => {\n      const result = await plugin.loadPackage(\"test.csv\")\n\n      expect(mockLoadPackageFromDatabase).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for http urls\", async () => {\n      const result = await plugin.loadPackage(\"https://example.com/data\")\n\n      expect(mockLoadPackageFromDatabase).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n\n  describe(\"savePackage\", () => {\n    it(\"should save package to postgresql database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockSavePackageToDatabase.mockResolvedValue(undefined)\n\n      await plugin.savePackage(mockPackage, {\n        target: \"postgresql://localhost/testdb\",\n      })\n\n      expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {\n        target: \"postgresql://localhost/testdb\",\n        format: \"postgresql\",\n      })\n    })\n\n    it(\"should save package to mysql database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockSavePackageToDatabase.mockResolvedValue(undefined)\n\n      await plugin.savePackage(mockPackage, {\n        target: \"mysql://localhost/testdb\",\n      })\n\n      expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {\n        target: \"mysql://localhost/testdb\",\n        format: \"mysql\",\n      })\n    })\n\n    it(\"should save package to sqlite database\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockSavePackageToDatabase.mockResolvedValue(undefined)\n\n      await plugin.savePackage(mockPackage, { target: \"sqlite://test.db\" })\n\n      expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {\n        target: \"sqlite://test.db\",\n        format: \"sqlite\",\n      })\n    })\n\n    it(\"should return undefined for non-database targets\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n\n      const result = await plugin.savePackage(mockPackage, {\n        target: \"test.csv\",\n      })\n\n      expect(mockSavePackageToDatabase).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should pass through plugins option\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      const mockPlugins: any[] = []\n      mockSavePackageToDatabase.mockResolvedValue(undefined)\n\n      await plugin.savePackage(mockPackage, {\n        target: \"sqlite://test.db\",\n        plugins: mockPlugins,\n      })\n\n      expect(mockSavePackageToDatabase).toHaveBeenCalledWith(mockPackage, {\n        target: \"sqlite://test.db\",\n        format: \"sqlite\",\n        plugins: mockPlugins,\n      })\n    })\n  })\n\n  describe(\"loadTable\", () => {\n    it(\"should load table from postgresql resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"postgresql://localhost/testdb\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadDatabaseTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadDatabaseTable).toHaveBeenCalledWith({\n        ...resource,\n        format: \"postgresql\",\n      })\n      expect(result).toEqual(mockTable)\n    })\n\n    it(\"should load table from mysql resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"mysql://localhost/testdb\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadDatabaseTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadDatabaseTable).toHaveBeenCalledWith({\n        ...resource,\n        format: \"mysql\",\n      })\n      expect(result).toEqual(mockTable)\n    })\n\n    it(\"should load table from sqlite resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"sqlite://test.db\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadDatabaseTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadDatabaseTable).toHaveBeenCalledWith({\n        ...resource,\n        format: \"sqlite\",\n      })\n      expect(result).toEqual(mockTable)\n    })\n\n    it(\"should return undefined for non-database resources\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.csv\",\n      }\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadDatabaseTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle explicit format specification\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.txt\",\n        format: \"sqlite\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadDatabaseTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadDatabaseTable).toHaveBeenCalledWith({\n        ...resource,\n        format: \"sqlite\",\n      })\n      expect(result).toEqual(mockTable)\n    })\n  })\n\n  describe(\"saveTable\", () => {\n    it(\"should save table to postgresql database\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"postgresql://localhost/testdb\" }\n      mockSaveDatabaseTable.mockResolvedValue(\"postgresql://localhost/testdb\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {\n        ...options,\n        format: \"postgresql\",\n      })\n      expect(result).toBe(\"postgresql://localhost/testdb\")\n    })\n\n    it(\"should save table to mysql database\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"mysql://localhost/testdb\" }\n      mockSaveDatabaseTable.mockResolvedValue(\"mysql://localhost/testdb\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {\n        ...options,\n        format: \"mysql\",\n      })\n      expect(result).toBe(\"mysql://localhost/testdb\")\n    })\n\n    it(\"should save table to sqlite database\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"sqlite://test.db\" }\n      mockSaveDatabaseTable.mockResolvedValue(\"sqlite://test.db\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {\n        ...options,\n        format: \"sqlite\",\n      })\n      expect(result).toBe(\"sqlite://test.db\")\n    })\n\n    it(\"should return undefined for non-database paths\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.csv\" }\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveDatabaseTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle explicit format specification\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"test.txt\", format: \"sqlite\" as const }\n      mockSaveDatabaseTable.mockResolvedValue(\"test.txt\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveDatabaseTable).toHaveBeenCalledWith(table, {\n        ...options,\n        format: \"sqlite\",\n      })\n      expect(result).toBe(\"test.txt\")\n    })\n  })\n\n  describe(\"inferSchema\", () => {\n    it(\"should infer schema for postgresql resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"postgresql://localhost/testdb\",\n      }\n      const mockSchema = { fields: [] }\n      mockInferDatabaseSchema.mockResolvedValue(mockSchema)\n\n      const result = await plugin.inferSchema(resource)\n\n      expect(mockInferDatabaseSchema).toHaveBeenCalledWith({\n        ...resource,\n        format: \"postgresql\",\n      })\n      expect(result).toEqual(mockSchema)\n    })\n\n    it(\"should infer schema for mysql resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"mysql://localhost/testdb\",\n      }\n      const mockSchema = { fields: [] }\n      mockInferDatabaseSchema.mockResolvedValue(mockSchema)\n\n      const result = await plugin.inferSchema(resource)\n\n      expect(mockInferDatabaseSchema).toHaveBeenCalledWith({\n        ...resource,\n        format: \"mysql\",\n      })\n      expect(result).toEqual(mockSchema)\n    })\n\n    it(\"should infer schema for sqlite resource\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"sqlite://test.db\",\n      }\n      const mockSchema = { fields: [] }\n      mockInferDatabaseSchema.mockResolvedValue(mockSchema)\n\n      const result = await plugin.inferSchema(resource)\n\n      expect(mockInferDatabaseSchema).toHaveBeenCalledWith({\n        ...resource,\n        format: \"sqlite\",\n      })\n      expect(result).toEqual(mockSchema)\n    })\n\n    it(\"should return undefined for non-database resources\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.csv\",\n      }\n\n      const result = await plugin.inferSchema(resource)\n\n      expect(mockInferDatabaseSchema).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle explicit format specification\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.txt\",\n        format: \"sqlite\",\n      }\n      const mockSchema = { fields: [] }\n      mockInferDatabaseSchema.mockResolvedValue(mockSchema)\n\n      const result = await plugin.inferSchema(resource)\n\n      expect(mockInferDatabaseSchema).toHaveBeenCalledWith({\n        ...resource,\n        format: \"sqlite\",\n      })\n      expect(result).toEqual(mockSchema)\n    })\n  })\n})\n"]}

package/build/resource/Format.d.ts

@@ -0,0 +1 @@
+export type DatabaseFormat = "sqlite" | "postgresql" | "mysql";

package/build/resource/Format.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRm9ybWF0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vcmVzb3VyY2UvRm9ybWF0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBEYXRhYmFzZUZvcm1hdCA9IFwic3FsaXRlXCIgfCBcInBvc3RncmVzcWxcIiB8IFwibXlzcWxcIlxuIl19

package/build/resource/index.d.ts

@@ -0,0 +1 @@
+export type { DatabaseFormat } from "./Format.ts";

package/build/resource/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9yZXNvdXJjZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgeyBEYXRhYmFzZUZvcm1hdCB9IGZyb20gXCIuL0Zvcm1hdC50c1wiXG4iXX0=

package/build/schema/Schema.d.ts

@@ -0,0 +1,4 @@
+import type { TableMetadata } from "kysely";
+export interface DatabaseSchema extends TableMetadata {
+    primaryKey?: string[];
+}

package/build/schema/Schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2NoZW1hL1NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUYWJsZU1ldGFkYXRhIH0gZnJvbSBcImt5c2VseVwiXG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YWJhc2VTY2hlbWEgZXh0ZW5kcyBUYWJsZU1ldGFkYXRhIHtcbiAgcHJpbWFyeUtleT86IHN0cmluZ1tdXG59XG4iXX0=

package/build/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { inferDatabaseSchema } from "./infer.ts";
+export type { DatabaseSchema } from "./Schema.ts";

package/build/schema/index.js

@@ -0,0 +1,2 @@
+export { inferDatabaseSchema } from "./infer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zY2hlbWEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sWUFBWSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgaW5mZXJEYXRhYmFzZVNjaGVtYSB9IGZyb20gXCIuL2luZmVyLnRzXCJcbmV4cG9ydCB0eXBlIHsgRGF0YWJhc2VTY2hlbWEgfSBmcm9tIFwiLi9TY2hlbWEudHNcIlxuIl19

package/build/schema/infer.d.ts

@@ -0,0 +1,4 @@
+import type { Resource } from "@frictionless-ts/metadata";
+export declare function inferDatabaseSchema(resource: Partial<Resource> & {
+    format: "postgresql" | "mysql" | "sqlite";
+}): Promise<import("@frictionless-ts/metadata").Schema>;

package/build/schema/infer.js

@@ -0,0 +1,24 @@
+import { resolveDialect } from "@frictionless-ts/metadata";
+import { createAdapter } from "../adapters/create.js";
+export async function inferDatabaseSchema(resource) {
+    const adapter = createAdapter(resource.format);
+    if (!adapter) {
+        throw new Error("Supported database format is not defined");
+    }
+    const dialect = await resolveDialect(resource.dialect);
+    if (!dialect?.table) {
+        throw new Error("Table name is not defined in dialect");
+    }
+    const path = typeof resource.path === "string" ? resource.path : undefined;
+    if (!path) {
+        throw new Error("Resource path is not defined");
+    }
+    const database = await adapter.connectDatabase(path);
+    const databaseSchemas = await database.introspection.getTables();
+    const databaseSchema = databaseSchemas.find(s => s.name === dialect.table);
+    if (!databaseSchema) {
+        throw new Error(`Table is not found in database: ${dialect.table}`);
+    }
+    return adapter.normalizeSchema(databaseSchema);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/infer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/schema/infer.spec.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { inferDatabaseSchema } from "./infer.js";
+// TODO: Enable when SQLite support is fixed
+describe.skip("inferDatabaseSchema", () => {
+    it("throws error when resource path is not defined", async () => {
+        await expect(inferDatabaseSchema({
+            format: "sqlite",
+            dialect: { table: "dpkit" },
+        })).rejects.toThrow("Resource path is not defined");
+    });
+    it("throws error when table name is not defined in dialect", async () => {
+        await expect(inferDatabaseSchema({
+            path: "path",
+            format: "sqlite",
+        })).rejects.toThrow("Table name is not defined in dialect");
+    });
+    it("throws error when format is not supported", async () => {
+        await expect(inferDatabaseSchema({
+            path: "path",
+            format: "unsupported",
+            dialect: { table: "dpkit" },
+        })).rejects.toThrow('Unsupported database format: "unsupported"');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/index.d.ts

@@ -0,0 +1,2 @@
+export { loadDatabaseTable } from "./load.ts";
+export { saveDatabaseTable } from "./save.ts";

package/build/table/index.js

@@ -0,0 +1,3 @@
+export { loadDatabaseTable } from "./load.js";
+export { saveDatabaseTable } from "./save.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90YWJsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDN0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sV0FBVyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgbG9hZERhdGFiYXNlVGFibGUgfSBmcm9tIFwiLi9sb2FkLnRzXCJcbmV4cG9ydCB7IHNhdmVEYXRhYmFzZVRhYmxlIH0gZnJvbSBcIi4vc2F2ZS50c1wiXG4iXX0=

package/build/table/load.d.ts

@@ -0,0 +1,6 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions } from "@frictionless-ts/table";
+import * as pl from "nodejs-polars";
+export declare function loadDatabaseTable(resource: Partial<Resource> & {
+    format: "postgresql" | "mysql" | "sqlite";
+}, options?: LoadTableOptions): Promise<pl.LazyDataFrame<any>>;

package/build/table/load.js

@@ -0,0 +1,29 @@
+import { resolveDialect, resolveSchema } from "@frictionless-ts/metadata";
+import { normalizeTable } from "@frictionless-ts/table";
+import * as pl from "nodejs-polars";
+import { createAdapter } from "../adapters/create.js";
+import { inferDatabaseSchema } from "../schema/index.js";
+// Currently, we use slow non-rust implementation as in the future
+// polars-rust might be able to provide a faster native implementation
+export async function loadDatabaseTable(resource, options) {
+    const dialect = await resolveDialect(resource.dialect);
+    if (!dialect?.table) {
+        throw new Error("Table name is not defined in dialect");
+    }
+    const path = typeof resource.path === "string" ? resource.path : undefined;
+    if (!path) {
+        throw new Error("Resource path is not defined");
+    }
+    const adapter = createAdapter(resource.format);
+    const database = await adapter.connectDatabase(path);
+    const records = await database.selectFrom(dialect.table).selectAll().execute();
+    let table = pl.DataFrame(records).lazy();
+    if (!options?.denormalized) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferDatabaseSchema(resource);
+        table = await normalizeTable(table, schema);
+    }
+    return table;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/load.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/table/load.spec.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { loadDatabaseTable } from "./load.js";
+describe("loadDatabaseTable", () => {
+    it("throws error when resource path is not defined", async () => {
+        await expect(loadDatabaseTable({
+            format: "sqlite",
+            dialect: { table: "dpkit" },
+        })).rejects.toThrow("Resource path is not defined");
+    });
+    it("throws error when table name is not defined in dialect", async () => {
+        await expect(loadDatabaseTable({
+            path: "path",
+            format: "sqlite",
+        })).rejects.toThrow("Table name is not defined in dialect");
+    });
+    it("throws error when format is not supported", async () => {
+        await expect(loadDatabaseTable({
+            path: "path",
+            format: "unsupported",
+            dialect: { table: "dpkit" },
+        })).rejects.toThrow('Unsupported database format: "unsupported"');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/save.d.ts

@@ -0,0 +1,4 @@
+import type { SaveTableOptions, Table } from "@frictionless-ts/table";
+export declare function saveDatabaseTable(table: Table, options: SaveTableOptions & {
+    format: "postgresql" | "mysql" | "sqlite";
+}): Promise<string>;