@frictionless-ts/database 1.0.1

package/build/adapters/postgresql.spec.js

@@ -0,0 +1,170 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { useRecording } from "vitest-polly";
+import { loadPackageFromDatabase } from "../package/index.js";
+import { inferDatabaseSchema } from "../schema/index.js";
+import { loadDatabaseTable, saveDatabaseTable } from "../table/index.js";
+import { createAdapter } from "./create.js";
+useRecording();
+const path = process.env.DPKIT_POSTGRESQL_URL;
+// Vitest runs in-file tests sequentially so we can use the same table
+const dialect = { table: "dpkit" };
+const record1 = { id: 1, name: "english" };
+const record2 = { id: 2, name: "中文" };
+describe.skipIf(!path)("PostgresqlAdapter", () => {
+    if (!path)
+        return;
+    it("should infer schema", async () => {
+        const source = pl
+            .DataFrame([
+            pl.Series("string", ["string"], pl.Utf8),
+            pl.Series("integer", [1], pl.Int32),
+            pl.Series("number", [1.1], pl.Float64),
+        ])
+            .lazy();
+        await saveDatabaseTable(source, {
+            path,
+            dialect,
+            format: "postgresql",
+            overwrite: true,
+        });
+        const schema = await inferDatabaseSchema({
+            path,
+            dialect,
+            format: "postgresql",
+        });
+        expect(schema).toEqual({
+            fields: [
+                { name: "string", type: "string" },
+                { name: "integer", type: "integer" },
+                { name: "number", type: "number" },
+            ],
+        });
+    });
+    it("should save/load table", async () => {
+        const source = pl.DataFrame([record1, record2]).lazy();
+        await saveDatabaseTable(source, {
+            path,
+            dialect,
+            format: "postgresql",
+            overwrite: true,
+        });
+        const target = await loadDatabaseTable({
+            path,
+            dialect,
+            format: "postgresql",
+        });
+        expect((await target.collect()).toRecords()).toEqual([record1, record2]);
+    });
+    it("should save/load table with various data types", async () => {
+        const source = pl
+            .DataFrame([
+            pl.Series("array", ["[1, 2, 3]"], pl.String),
+            pl.Series("boolean", [true], pl.Bool),
+            pl.Series("date", [new Date(Date.UTC(2025, 0, 1))], pl.Date),
+            pl.Series("datetime", [new Date(Date.UTC(2025, 0, 1))], pl.Datetime),
+            pl.Series("duration", ["P23DT23H"], pl.String),
+            pl.Series("geojson", ['{"value": 1}'], pl.String),
+            pl.Series("geopoint", [[40.0, 50.0]], pl.List(pl.Float32)),
+            pl.Series("integer", [1], pl.Int32),
+            pl.Series("list", [[1.0, 2.0, 3.0]], pl.List(pl.Float32)),
+            pl.Series("number", [1.1], pl.Float64),
+            pl.Series("object", ['{"value": 1}']),
+            pl.Series("string", ["string"], pl.String),
+            pl.Series("time", [new Date(Date.UTC(2025, 0, 1))], pl.Time),
+            pl.Series("year", [2025], pl.Int32),
+            pl.Series("yearmonth", [[2025, 1]], pl.List(pl.Int16)),
+        ])
+            .lazy();
+        await saveDatabaseTable(source, {
+            path,
+            dialect,
+            format: "postgresql",
+            overwrite: true,
+            fieldTypes: {
+                geojson: "geojson",
+                geopoint: "geopoint",
+                list: "list",
+                object: "object",
+                // TODO: Remove time after:
+                // https://github.com/pola-rs/nodejs-polars/issues/364
+                time: "time",
+                year: "year",
+                yearmonth: "yearmonth",
+            },
+        });
+        const target = await loadDatabaseTable({ path, dialect, format: "postgresql" }, { denormalized: true });
+        expect((await target.collect()).toRecords()).toEqual([
+            {
+                array: "[1, 2, 3]",
+                boolean: true,
+                date: "2025-01-01",
+                datetime: new Date(Date.UTC(2025, 0, 1)),
+                duration: "P23DT23H",
+                geojson: '{"value": 1}',
+                geopoint: "40.0,50.0",
+                integer: 1,
+                list: "1.0,2.0,3.0",
+                number: 1.1,
+                object: '{"value": 1}',
+                string: "string",
+                time: "00:00:00",
+                year: 2025,
+                yearmonth: "2025-01",
+            },
+        ]);
+    });
+    it("should load package from database", async () => {
+        const adapter = createAdapter("postgresql");
+        const database = await adapter.connectDatabase(path);
+        await database.schema.dropTable("table1").ifExists().execute();
+        await database.schema
+            .createTable("table1")
+            .ifNotExists()
+            .addColumn("id", "integer", column => column.notNull())
+            .addColumn("name", "text")
+            .execute();
+        await database.schema.dropTable("table2").ifExists().execute();
+        await database.schema
+            .createTable("table2")
+            .ifNotExists()
+            .addColumn("id", "integer", column => column.notNull())
+            .addColumn("number", "numeric")
+            .addColumn("datetime", "timestamp")
+            .execute();
+        const datapackage = await loadPackageFromDatabase(path, {
+            format: "postgresql",
+            includeTables: ["table1", "table2"],
+        });
+        expect(datapackage).toEqual({
+            resources: [
+                {
+                    path,
+                    name: "table1",
+                    format: "postgresql",
+                    dialect: { table: "table1" },
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer", constraints: { required: true } },
+                            { name: "name", type: "string" },
+                        ],
+                    },
+                },
+                {
+                    path,
+                    name: "table2",
+                    format: "postgresql",
+                    dialect: { table: "table2" },
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer", constraints: { required: true } },
+                            { name: "number", type: "number" },
+                            { name: "datetime", type: "datetime" },
+                        ],
+                    },
+                },
+            ],
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postgresql.spec.js","sourceRoot":"","sources":["../../adapters/postgresql.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { useRecording } from \"vitest-polly\"\nimport { loadPackageFromDatabase } from \"../package/index.ts\"\nimport { inferDatabaseSchema } from \"../schema/index.ts\"\nimport { loadDatabaseTable, saveDatabaseTable } from \"../table/index.ts\"\nimport { createAdapter } from \"./create.ts\"\n\nuseRecording()\n\nconst path = process.env.DPKIT_POSTGRESQL_URL\n\n// Vitest runs in-file tests sequentially so we can use the same table\nconst dialect = { table: \"dpkit\" }\nconst record1 = { id: 1, name: \"english\" }\nconst record2 = { id: 2, name: \"中文\" }\n\ndescribe.skipIf(!path)(\"PostgresqlAdapter\", () => {\n  if (!path) return\n\n  it(\"should infer schema\", async () => {\n    const source = pl\n      .DataFrame([\n        pl.Series(\"string\", [\"string\"], pl.Utf8),\n        pl.Series(\"integer\", [1], pl.Int32),\n        pl.Series(\"number\", [1.1], pl.Float64),\n      ])\n      .lazy()\n\n    await saveDatabaseTable(source, {\n      path,\n      dialect,\n      format: \"postgresql\",\n      overwrite: true,\n    })\n\n    const schema = await inferDatabaseSchema({\n      path,\n      dialect,\n      format: \"postgresql\",\n    })\n\n    expect(schema).toEqual({\n      fields: [\n        { name: \"string\", type: \"string\" },\n        { name: \"integer\", type: \"integer\" },\n        { name: \"number\", type: \"number\" },\n      ],\n    })\n  })\n\n  it(\"should save/load table\", async () => {\n    const source = pl.DataFrame([record1, record2]).lazy()\n\n    await saveDatabaseTable(source, {\n      path,\n      dialect,\n      format: \"postgresql\",\n      overwrite: true,\n    })\n\n    const target = await loadDatabaseTable({\n      path,\n      dialect,\n      format: \"postgresql\",\n    })\n\n    expect((await target.collect()).toRecords()).toEqual([record1, record2])\n  })\n\n  it(\"should save/load table with various data types\", async () => {\n    const source = pl\n      .DataFrame([\n        pl.Series(\"array\", [\"[1, 2, 3]\"], pl.String),\n        pl.Series(\"boolean\", [true], pl.Bool),\n        pl.Series(\"date\", [new Date(Date.UTC(2025, 0, 1))], pl.Date),\n        pl.Series(\"datetime\", [new Date(Date.UTC(2025, 0, 1))], pl.Datetime),\n        pl.Series(\"duration\", [\"P23DT23H\"], pl.String),\n        pl.Series(\"geojson\", ['{\"value\": 1}'], pl.String),\n        pl.Series(\"geopoint\", [[40.0, 50.0]], pl.List(pl.Float32)),\n        pl.Series(\"integer\", [1], pl.Int32),\n        pl.Series(\"list\", [[1.0, 2.0, 3.0]], pl.List(pl.Float32)),\n        pl.Series(\"number\", [1.1], pl.Float64),\n        pl.Series(\"object\", ['{\"value\": 1}']),\n        pl.Series(\"string\", [\"string\"], pl.String),\n        pl.Series(\"time\", [new Date(Date.UTC(2025, 0, 1))], pl.Time),\n        pl.Series(\"year\", [2025], pl.Int32),\n        pl.Series(\"yearmonth\", [[2025, 1]], pl.List(pl.Int16)),\n      ])\n      .lazy()\n\n    await saveDatabaseTable(source, {\n      path,\n      dialect,\n      format: \"postgresql\",\n      overwrite: true,\n      fieldTypes: {\n        geojson: \"geojson\",\n        geopoint: \"geopoint\",\n        list: \"list\",\n        object: \"object\",\n        // TODO: Remove time after:\n        // https://github.com/pola-rs/nodejs-polars/issues/364\n        time: \"time\",\n        year: \"year\",\n        yearmonth: \"yearmonth\",\n      },\n    })\n\n    const target = await loadDatabaseTable(\n      { path, dialect, format: \"postgresql\" },\n      { denormalized: true },\n    )\n\n    expect((await target.collect()).toRecords()).toEqual([\n      {\n        array: \"[1, 2, 3]\",\n        boolean: true,\n        date: \"2025-01-01\",\n        datetime: new Date(Date.UTC(2025, 0, 1)),\n        duration: \"P23DT23H\",\n        geojson: '{\"value\": 1}',\n        geopoint: \"40.0,50.0\",\n        integer: 1,\n        list: \"1.0,2.0,3.0\",\n        number: 1.1,\n        object: '{\"value\": 1}',\n        string: \"string\",\n        time: \"00:00:00\",\n        year: 2025,\n        yearmonth: \"2025-01\",\n      },\n    ])\n  })\n\n  it(\"should load package from database\", async () => {\n    const adapter = createAdapter(\"postgresql\")\n    const database = await adapter.connectDatabase(path)\n\n    await database.schema.dropTable(\"table1\").ifExists().execute()\n    await database.schema\n      .createTable(\"table1\")\n      .ifNotExists()\n      .addColumn(\"id\", \"integer\", column => column.notNull())\n      .addColumn(\"name\", \"text\")\n      .execute()\n\n    await database.schema.dropTable(\"table2\").ifExists().execute()\n    await database.schema\n      .createTable(\"table2\")\n      .ifNotExists()\n      .addColumn(\"id\", \"integer\", column => column.notNull())\n      .addColumn(\"number\", \"numeric\")\n      .addColumn(\"datetime\", \"timestamp\")\n      .execute()\n\n    const datapackage = await loadPackageFromDatabase(path, {\n      format: \"postgresql\",\n      includeTables: [\"table1\", \"table2\"],\n    })\n\n    expect(datapackage).toEqual({\n      resources: [\n        {\n          path,\n          name: \"table1\",\n          format: \"postgresql\",\n          dialect: { table: \"table1\" },\n          schema: {\n            fields: [\n              { name: \"id\", type: \"integer\", constraints: { required: true } },\n              { name: \"name\", type: \"string\" },\n            ],\n          },\n        },\n        {\n          path,\n          name: \"table2\",\n          format: \"postgresql\",\n          dialect: { table: \"table2\" },\n          schema: {\n            fields: [\n              { name: \"id\", type: \"integer\", constraints: { required: true } },\n              { name: \"number\", type: \"number\" },\n              { name: \"datetime\", type: \"datetime\" },\n            ],\n          },\n        },\n      ],\n    })\n  })\n})\n"]}

package/build/adapters/sqlite.bun.d.ts

@@ -0,0 +1,2 @@
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+export declare function createBunSqliteDialect(path: string): Promise<BunSqliteDialect>;

package/build/adapters/sqlite.bun.js

@@ -0,0 +1,7 @@
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+export async function createBunSqliteDialect(path) {
+    // @ts-ignore
+    const { Database } = await import("bun:sqlite");
+    return new BunSqliteDialect({ database: new Database(path) });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlLmJ1bi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2FkYXB0ZXJzL3NxbGl0ZS5idW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFFcEQsTUFBTSxDQUFDLEtBQUssVUFBVSxzQkFBc0IsQ0FBQyxJQUFZO0lBQ3ZELGFBQWE7SUFDYixNQUFNLEVBQUUsUUFBUSxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUE7SUFDL0MsT0FBTyxJQUFJLGdCQUFnQixDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksUUFBUSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtBQUMvRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQnVuU3FsaXRlRGlhbGVjdCB9IGZyb20gXCJreXNlbHktYnVuLXNxbGl0ZVwiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjcmVhdGVCdW5TcWxpdGVEaWFsZWN0KHBhdGg6IHN0cmluZykge1xuICAvLyBAdHMtaWdub3JlXG4gIGNvbnN0IHsgRGF0YWJhc2UgfSA9IGF3YWl0IGltcG9ydChcImJ1bjpzcWxpdGVcIilcbiAgcmV0dXJuIG5ldyBCdW5TcWxpdGVEaWFsZWN0KHsgZGF0YWJhc2U6IG5ldyBEYXRhYmFzZShwYXRoKSB9KVxufVxuIl19

package/build/adapters/sqlite.d.ts

@@ -0,0 +1,11 @@
+import type { FieldType } from "@frictionless-ts/metadata";
+import type { DatabaseType } from "../field/index.ts";
+import { BaseAdapter } from "./base.ts";
+export declare class SqliteAdapter extends BaseAdapter {
+    nativeTypes: ("string" | "number" | "integer" | "year")[];
+    createDialect(path: string, options?: {
+        create?: boolean;
+    }): Promise<import("kysely-bun-sqlite").BunSqliteDialect | import("kysely-generic-sqlite").GenericSqliteDialect>;
+    normalizeType(databaseType: DatabaseType): FieldType;
+    denormalizeType(fieldType: FieldType): DatabaseType;
+}

package/build/adapters/sqlite.js

@@ -0,0 +1,57 @@
+import { isLocalPathExist } from "@frictionless-ts/dataset";
+import { BaseAdapter } from "./base.js";
+// TODO: Currently, the solution is not optimal / hacky
+// We need to rebase on proper sqlite dialect when it will be available
+// - https://github.com/kysely-org/kysely/issues/1292
+// - https://github.com/oven-sh/bun/issues/20412
+export class SqliteAdapter extends BaseAdapter {
+    nativeTypes = ["integer", "number", "string", "year"];
+    async createDialect(path, options) {
+        path = path.replace(/^sqlite:\/\//, "");
+        if (!options?.create) {
+            const isExist = await isLocalPathExist(path);
+            if (!isExist) {
+                throw new Error(`Database file "${path}" does not exist`);
+            }
+        }
+        // @ts-ignore
+        if (typeof Bun !== "undefined") {
+            const { createBunSqliteDialect } = await import("./sqlite.bun.js");
+            return await createBunSqliteDialect(path);
+        }
+        const { createNodeSqliteDialect } = await import("./sqlite.node.js");
+        return await createNodeSqliteDialect(path);
+    }
+    normalizeType(databaseType) {
+        switch (databaseType.toLowerCase()) {
+            case "blob":
+                return "string";
+            case "text":
+                return "string";
+            case "integer":
+                return "integer";
+            case "numeric":
+            case "real":
+                return "number";
+            default:
+                return "string";
+        }
+    }
+    denormalizeType(fieldType) {
+        switch (fieldType) {
+            case "boolean":
+                return "integer";
+            case "integer":
+                return "integer";
+            case "number":
+                return "real";
+            case "string":
+                return "text";
+            case "year":
+                return "integer";
+            default:
+                return "text";
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/adapters/sqlite.node.d.ts

@@ -0,0 +1,2 @@
+import { GenericSqliteDialect } from "kysely-generic-sqlite";
+export declare function createNodeSqliteDialect(path: string): Promise<GenericSqliteDialect>;

package/build/adapters/sqlite.node.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { buildQueryFn, parseBigInt } from "kysely-generic-sqlite";
+import { GenericSqliteDialect } from "kysely-generic-sqlite";
+export async function createNodeSqliteDialect(path) {
+    const { DatabaseSync } = await import("node:sqlite");
+    return new GenericSqliteDialect(() => createSqliteExecutor(new DatabaseSync(path)));
+}
+function createSqliteExecutor(db) {
+    const getStmt = (sql) => {
+        const stmt = db.prepare(sql);
+        // We change it from original to use plain numbers
+        //stmt.setReadBigInts(true)
+        return stmt;
+    };
+    return {
+        db,
+        query: buildQueryFn({
+            all: (sql, parameters = []) => getStmt(sql)
+                .all(...parameters)
+                // We change it from original to make it work
+                // (by default it returns object with null prototype which breaks polars)
+                .map(row => ({ ...row })),
+            run: (sql, parameters = []) => {
+                const { changes, lastInsertRowid } = getStmt(sql).run(...parameters);
+                return {
+                    insertId: parseBigInt(lastInsertRowid),
+                    numAffectedRows: parseBigInt(changes),
+                };
+            },
+        }),
+        close: () => db.close(),
+        iterator: (isSelect, sql, parameters = []) => {
+            if (!isSelect) {
+                throw new Error("Only support select in stream()");
+            }
+            return getStmt(sql)
+                .iterate(...parameters) // We change it from original to make it work
+                // (by default it returns object with null prototype which breaks polars)
+                .map(row => ({ ...row }));
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/adapters/sqlite.spec.d.ts

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