@frictionless-ts/database 1.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © `2025` `Evgeny Karev`
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @frictionless-ts/database
+
+frictionless-ts is a fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://frictionlessdata.github.io/frictionless-ts/).

package/build/adapters/base.d.ts

@@ -0,0 +1,20 @@
+import type { Field, FieldType, Schema } from "@frictionless-ts/metadata";
+import type { Dialect } from "kysely";
+import { Kysely } from "kysely";
+import type { DatabaseField, DatabaseType } from "../field/index.ts";
+import type { DatabaseSchema } from "../schema/index.ts";
+export declare abstract class BaseAdapter {
+    abstract get nativeTypes(): FieldType[];
+    connectDatabase(path: string, options?: {
+        create?: boolean;
+    }): Promise<Kysely<any>>;
+    abstract createDialect(path: string, options?: {
+        create?: boolean;
+    }): Promise<Dialect>;
+    normalizeSchema(databaseSchema: DatabaseSchema): Schema;
+    normalizeField(databaseField: DatabaseField): Field;
+    abstract normalizeType(databaseType: DatabaseType): Field["type"];
+    denormalizeSchema(schema: Schema, tableName: string): DatabaseSchema;
+    denormalizeField(field: Field): DatabaseField;
+    abstract denormalizeType(fieldType: Field["type"]): DatabaseType;
+}

package/build/adapters/base.js

@@ -0,0 +1,66 @@
+import { Kysely } from "kysely";
+import { LRUCache } from "lru-cache";
+// We cache database connections (only works in serverfull environments)
+const databases = new LRUCache({
+    dispose: database => database.destroy(),
+    max: 10,
+});
+export class BaseAdapter {
+    async connectDatabase(path, options) {
+        const cachedDatabase = databases.get(path);
+        if (cachedDatabase) {
+            return cachedDatabase;
+        }
+        const dialect = await this.createDialect(path, options);
+        const database = new Kysely({ dialect });
+        databases.set(path, new Kysely({ dialect }));
+        return database;
+    }
+    normalizeSchema(databaseSchema) {
+        const schema = { fields: [] };
+        for (const databaseField of databaseSchema.columns) {
+            schema.fields.push(this.normalizeField(databaseField));
+        }
+        return schema;
+    }
+    normalizeField(databaseField) {
+        const field = {
+            name: databaseField.name,
+            type: this.normalizeType(databaseField.dataType),
+        };
+        if (!databaseField.isNullable) {
+            field.constraints ??= {};
+            field.constraints.required = true;
+        }
+        if (databaseField.comment) {
+            field.description = databaseField.comment;
+        }
+        return field;
+    }
+    denormalizeSchema(schema, tableName) {
+        const databaseSchema = {
+            name: tableName,
+            columns: [],
+            isView: false,
+        };
+        for (const field of schema.fields) {
+            databaseSchema.columns.push(this.denormalizeField(field));
+        }
+        if (schema.primaryKey) {
+            databaseSchema.primaryKey = schema.primaryKey;
+        }
+        return databaseSchema;
+    }
+    denormalizeField(field) {
+        const databaseField = {
+            name: field.name,
+            dataType: this.denormalizeType(field.type),
+            isNullable: !field.constraints?.required,
+            comment: field.description,
+            isAutoIncrementing: false,
+            hasDefaultValue: false,
+        };
+        return databaseField;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/adapters/create.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseFormat } from "../resource/index.ts";
+import { MysqlAdapter } from "./mysql.ts";
+import { PostgresqlAdapter } from "./postgresql.ts";
+import { SqliteAdapter } from "./sqlite.ts";
+export declare function createAdapter(format: DatabaseFormat): PostgresqlAdapter | MysqlAdapter | SqliteAdapter;

package/build/adapters/create.js

@@ -0,0 +1,17 @@
+import { MysqlAdapter } from "./mysql.js";
+import { PostgresqlAdapter } from "./postgresql.js";
+import { SqliteAdapter } from "./sqlite.js";
+// TODO: Enable SQLite support
+export function createAdapter(format) {
+    switch (format) {
+        case "postgresql":
+            return new PostgresqlAdapter();
+        case "mysql":
+            return new MysqlAdapter();
+        case "sqlite":
+            return new SqliteAdapter();
+        default:
+            throw new Error(`Unsupported database format: "${format}"`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYWRhcHRlcnMvY3JlYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDekMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDbkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUUzQyw4QkFBOEI7QUFFOUIsTUFBTSxVQUFVLGFBQWEsQ0FBQyxNQUFzQjtJQUNsRCxRQUFRLE1BQU0sRUFBRSxDQUFDO1FBQ2YsS0FBSyxZQUFZO1lBQ2YsT0FBTyxJQUFJLGlCQUFpQixFQUFFLENBQUE7UUFDaEMsS0FBSyxPQUFPO1lBQ1YsT0FBTyxJQUFJLFlBQVksRUFBRSxDQUFBO1FBQzNCLEtBQUssUUFBUTtZQUNYLE9BQU8sSUFBSSxhQUFhLEVBQUUsQ0FBQTtRQUM1QjtZQUNFLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLE1BQU0sR0FBRyxDQUFDLENBQUE7SUFDL0QsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERhdGFiYXNlRm9ybWF0IH0gZnJvbSBcIi4uL3Jlc291cmNlL2luZGV4LnRzXCJcbmltcG9ydCB7IE15c3FsQWRhcHRlciB9IGZyb20gXCIuL215c3FsLnRzXCJcbmltcG9ydCB7IFBvc3RncmVzcWxBZGFwdGVyIH0gZnJvbSBcIi4vcG9zdGdyZXNxbC50c1wiXG5pbXBvcnQgeyBTcWxpdGVBZGFwdGVyIH0gZnJvbSBcIi4vc3FsaXRlLnRzXCJcblxuLy8gVE9ETzogRW5hYmxlIFNRTGl0ZSBzdXBwb3J0XG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVBZGFwdGVyKGZvcm1hdDogRGF0YWJhc2VGb3JtYXQpIHtcbiAgc3dpdGNoIChmb3JtYXQpIHtcbiAgICBjYXNlIFwicG9zdGdyZXNxbFwiOlxuICAgICAgcmV0dXJuIG5ldyBQb3N0Z3Jlc3FsQWRhcHRlcigpXG4gICAgY2FzZSBcIm15c3FsXCI6XG4gICAgICByZXR1cm4gbmV3IE15c3FsQWRhcHRlcigpXG4gICAgY2FzZSBcInNxbGl0ZVwiOlxuICAgICAgcmV0dXJuIG5ldyBTcWxpdGVBZGFwdGVyKClcbiAgICBkZWZhdWx0OlxuICAgICAgdGhyb3cgbmV3IEVycm9yKGBVbnN1cHBvcnRlZCBkYXRhYmFzZSBmb3JtYXQ6IFwiJHtmb3JtYXR9XCJgKVxuICB9XG59XG4iXX0=

package/build/adapters/mysql.d.ts

@@ -0,0 +1,10 @@
+import type { FieldType } from "@frictionless-ts/metadata";
+import { MysqlDialect } from "kysely";
+import type { DatabaseType } from "../field/index.ts";
+import { BaseAdapter } from "./base.ts";
+export declare class MysqlAdapter extends BaseAdapter {
+    nativeTypes: ("string" | "number" | "boolean" | "integer" | "datetime" | "year")[];
+    createDialect(path: string): Promise<MysqlDialect>;
+    normalizeType(databaseType: DatabaseType): FieldType;
+    denormalizeType(fieldType: FieldType): DatabaseType;
+}

package/build/adapters/mysql.js

@@ -0,0 +1,90 @@
+import { MysqlDialect } from "kysely";
+import { createPool } from "mysql2";
+import { BaseAdapter } from "./base.js";
+// TODO: Support more native types
+export class MysqlAdapter extends BaseAdapter {
+    nativeTypes = [
+        "boolean",
+        "datetime",
+        "integer",
+        "number",
+        "string",
+        "year",
+    ];
+    async createDialect(path) {
+        return new MysqlDialect({
+            pool: createPool({ uri: path }),
+        });
+    }
+    normalizeType(databaseType) {
+        switch (databaseType.toLowerCase()) {
+            case "tinyint":
+            case "smallint":
+            case "mediumint":
+            case "int":
+            case "integer":
+            case "bigint":
+                return "integer";
+            case "decimal":
+            case "numeric":
+            case "float":
+            case "double":
+            case "real":
+                return "number";
+            case "bit":
+            case "bool":
+            case "boolean":
+                return "boolean";
+            case "char":
+            case "varchar":
+            case "tinytext":
+            case "text":
+            case "mediumtext":
+            case "longtext":
+            case "enum":
+            case "set":
+                return "string";
+            case "date":
+                return "date";
+            case "time":
+                return "time";
+            case "datetime":
+            case "timestamp":
+                return "datetime";
+            case "year":
+                return "year";
+            case "json":
+                return "object";
+            case "geometry":
+            case "point":
+            case "linestring":
+            case "polygon":
+            case "multipoint":
+            case "multilinestring":
+            case "multipolygon":
+            case "geometrycollection":
+                return "geojson";
+            default:
+                return "string";
+        }
+    }
+    denormalizeType(fieldType) {
+        switch (fieldType) {
+            case "boolean":
+                return "boolean";
+            case "datetime":
+                return "datetime";
+            case "integer":
+                return "integer";
+            case "number":
+                return "double precision";
+            case "string":
+                return "text";
+            case "year":
+                return "integer";
+            default:
+                return "text";
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/adapters/mysql.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_MYSQL_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)("MysqlAdapter", () => {
+    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: "mysql",
+            overwrite: true,
+        });
+        const schema = await inferDatabaseSchema({
+            path,
+            dialect,
+            format: "mysql",
+        });
+        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: "mysql",
+            overwrite: true,
+        });
+        const target = await loadDatabaseTable({
+            path,
+            dialect,
+            format: "mysql",
+        });
+        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: "mysql",
+            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: "mysql" }, { denormalized: true });
+        expect((await target.collect()).toRecords()).toEqual([
+            {
+                array: "[1, 2, 3]",
+                boolean: 1,
+                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("mysql");
+        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", "datetime")
+            .execute();
+        const datapackage = await loadPackageFromDatabase(path, {
+            format: "mysql",
+            includeTables: ["table1", "table2"],
+        });
+        expect(datapackage).toEqual({
+            resources: [
+                {
+                    path,
+                    name: "table1",
+                    format: "mysql",
+                    dialect: { table: "table1" },
+                    schema: {
+                        fields: [
+                            { name: "id", type: "integer", constraints: { required: true } },
+                            { name: "name", type: "string" },
+                        ],
+                    },
+                },
+                {
+                    path,
+                    name: "table2",
+                    format: "mysql",
+                    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":"mysql.spec.js","sourceRoot":"","sources":["../../adapters/mysql.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_MYSQL_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)(\"MysqlAdapter\", () => {\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: \"mysql\",\n      overwrite: true,\n    })\n\n    const schema = await inferDatabaseSchema({\n      path,\n      dialect,\n      format: \"mysql\",\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: \"mysql\",\n      overwrite: true,\n    })\n\n    const target = await loadDatabaseTable({\n      path,\n      dialect,\n      format: \"mysql\",\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: \"mysql\",\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: \"mysql\" },\n      { denormalized: true },\n    )\n\n    expect((await target.collect()).toRecords()).toEqual([\n      {\n        array: \"[1, 2, 3]\",\n        boolean: 1,\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(\"mysql\")\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\", \"datetime\")\n      .execute()\n\n    const datapackage = await loadPackageFromDatabase(path, {\n      format: \"mysql\",\n      includeTables: [\"table1\", \"table2\"],\n    })\n\n    expect(datapackage).toEqual({\n      resources: [\n        {\n          path,\n          name: \"table1\",\n          format: \"mysql\",\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: \"mysql\",\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/postgresql.d.ts

@@ -0,0 +1,10 @@
+import type { FieldType } from "@frictionless-ts/metadata";
+import { PostgresDialect } from "kysely";
+import type { DatabaseType } from "../field/index.ts";
+import { BaseAdapter } from "./base.ts";
+export declare class PostgresqlAdapter extends BaseAdapter {
+    nativeTypes: ("string" | "number" | "boolean" | "integer" | "datetime" | "year")[];
+    createDialect(path: string): Promise<PostgresDialect>;
+    normalizeType(databaseType: DatabaseType): FieldType;
+    denormalizeType(fieldType: FieldType): DatabaseType;
+}

package/build/adapters/postgresql.js

@@ -0,0 +1,100 @@
+import { PostgresDialect } from "kysely";
+import { Pool } from "pg";
+import { BaseAdapter } from "./base.js";
+// TODO: Support more native types
+export class PostgresqlAdapter extends BaseAdapter {
+    nativeTypes = [
+        "boolean",
+        "datetime",
+        "integer",
+        "number",
+        "string",
+        "year",
+    ];
+    async createDialect(path) {
+        return new PostgresDialect({
+            pool: new Pool({ connectionString: path }),
+        });
+    }
+    normalizeType(databaseType) {
+        switch (databaseType.toLowerCase()) {
+            case "smallint":
+            case "integer":
+            case "int":
+            case "int2":
+            case "int4":
+            case "int8":
+            case "bigint":
+            case "smallserial":
+            case "serial":
+            case "bigserial":
+                return "integer";
+            case "decimal":
+            case "numeric":
+            case "real":
+            case "float4":
+            case "double precision":
+            case "float8":
+                return "number";
+            case "boolean":
+            case "bool":
+                return "boolean";
+            case "char":
+            case "character":
+            case "varchar":
+            case "character varying":
+            case "text":
+            case "citext":
+            case "uuid":
+                return "string";
+            case "date":
+                return "date";
+            case "time":
+            case "time without time zone":
+            case "time with time zone":
+            case "timetz":
+                return "time";
+            case "timestamp":
+            case "timestamp without time zone":
+            case "timestamp with time zone":
+            case "timestamptz":
+                return "datetime";
+            case "interval":
+                return "duration";
+            case "json":
+            case "jsonb":
+                return "object";
+            case "point":
+            case "line":
+            case "lseg":
+            case "box":
+            case "path":
+            case "polygon":
+            case "circle":
+            case "geometry":
+            case "geography":
+                return "geojson";
+            default:
+                return "string";
+        }
+    }
+    denormalizeType(fieldType) {
+        switch (fieldType) {
+            case "boolean":
+                return "boolean";
+            case "datetime":
+                return "timestamp";
+            case "integer":
+                return "integer";
+            case "number":
+                return "double precision";
+            case "string":
+                return "text";
+            case "year":
+                return "integer";
+            default:
+                return "text";
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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