@frictionless-ts/dataset 1.0.1

package/build/plugins/ckan/package/save.js

@@ -0,0 +1,83 @@
+import { blob } from "node:stream/consumers";
+import { convertPackageToDescriptor, getFilename, getFormat, stringifyDescriptor, } from "@frictionless-ts/metadata";
+import { getPackageBasepath } from "../../../package/index.js";
+import { saveResourceFiles } from "../../../resource/index.js";
+import { loadFileStream } from "../../../stream/index.js";
+import { makeCkanApiRequest } from "../ckan/index.js";
+import { convertResourceToCkan } from "../resource/index.js";
+import { convertPackageToCkan } from "./convert/toCkan.js";
+export async function savePackageToCkan(dataPackage, options) {
+    const { apiKey, ckanUrl, ownerOrg, datasetName } = options;
+    const basepath = getPackageBasepath(dataPackage);
+    const ckanPackage = convertPackageToCkan(dataPackage);
+    const payload = {
+        ...ckanPackage,
+        name: datasetName,
+        owner_org: ownerOrg,
+        resources: [],
+    };
+    const result = await makeCkanApiRequest({
+        action: "package_create",
+        payload,
+        ckanUrl: ckanUrl,
+        apiKey: apiKey,
+    });
+    const url = new URL(ckanUrl);
+    url.pathname = `/dataset/${result.name}`;
+    const resourceDescriptors = [];
+    for (const resource of dataPackage.resources) {
+        resourceDescriptors.push(await saveResourceFiles(resource, {
+            basepath,
+            withRemote: true,
+            withoutFolders: true,
+            saveFile: async (options) => {
+                const filename = getFilename(options.normalizedPath);
+                const ckanResource = convertResourceToCkan(resource);
+                const payload = {
+                    ...ckanResource,
+                    package_id: datasetName,
+                    name: options.denormalizedPath,
+                    format: getFormat(filename)?.toUpperCase(),
+                };
+                const upload = {
+                    name: options.denormalizedPath,
+                    data: await blob(await loadFileStream(options.normalizedPath)),
+                };
+                const result = await makeCkanApiRequest({
+                    action: "resource_create",
+                    payload,
+                    upload,
+                    ckanUrl,
+                    apiKey,
+                });
+                return result.url;
+            },
+        }));
+    }
+    const descriptor = {
+        ...convertPackageToDescriptor(dataPackage, { basepath }),
+        resources: resourceDescriptors,
+    };
+    for (const denormalizedPath of ["datapackage.json"]) {
+        const payload = {
+            package_id: datasetName,
+            name: denormalizedPath,
+        };
+        const upload = {
+            name: denormalizedPath,
+            data: new Blob([stringifyDescriptor(descriptor)]),
+        };
+        await makeCkanApiRequest({
+            action: "resource_create",
+            payload,
+            upload,
+            ckanUrl,
+            apiKey,
+        });
+    }
+    return {
+        path: result.url,
+        datasetUrl: url.toString(),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/ckan/package/save.spec.d.ts

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

package/build/plugins/ckan/package/save.spec.js

@@ -0,0 +1,319 @@
+import { relative } from "node:path";
+import { loadPackageDescriptor } from "@frictionless-ts/metadata";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { savePackageToCkan } from "./save.js";
+describe("savePackageToCkan", () => {
+    const getFixturePath = (name) => relative(process.cwd(), `${import.meta.dirname}/fixtures/${name}`);
+    const mockPackage = {
+        name: "test-package",
+        title: "Test Package",
+        description: "A test package",
+        version: "1.0.0",
+        resources: [
+            {
+                name: "test-resource",
+                path: getFixturePath("data.csv"),
+                format: "csv",
+                bytes: 100,
+            },
+        ],
+    };
+    const mockOptions = {
+        apiKey: "test-api-key",
+        ckanUrl: "https://ckan.example.com",
+        ownerOrg: "test-org",
+        datasetName: "test-dataset",
+    };
+    const originalFetch = globalThis.fetch;
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn();
+        // @ts-ignore
+        globalThis.fetch = fetchMock;
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.resetAllMocks();
+    });
+    it.skip("should save a package", async () => {
+        const dataPackage = await loadPackageDescriptor("core/package/fixtures/package.json");
+        const result = await savePackageToCkan(dataPackage, {
+            ckanUrl: "http://localhost:5000/",
+            apiKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJ1T0Y0VUNybTU5Y0dzdlk3ejhreF9CeC02R0w4RDBOdW9QS0J0WkJFXzlJIiwiaWF0IjoxNzQ3OTI0NDg5fQ.ioGiLlZkm24xHQRBas5X5ig5eU7u_fIjkl4oifGnLaA",
+            datasetName: "test",
+            ownerOrg: "test",
+        });
+        expect(result).toBeDefined();
+    });
+    it("creates a package in CKAN with correct API calls", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-1",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-1",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-2",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-2",
+                },
+            }),
+        });
+        const result = await savePackageToCkan(mockPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        const packageCreateCall = fetchMock.mock.calls[0];
+        expect(packageCreateCall).toBeDefined();
+        if (!packageCreateCall)
+            return;
+        expect(packageCreateCall[0]).toEqual("https://ckan.example.com/api/3/action/package_create");
+        expect(packageCreateCall[1]).toMatchObject({
+            method: "POST",
+            headers: {
+                Authorization: "test-api-key",
+                "Content-Type": "application/json",
+            },
+        });
+        const packagePayload = JSON.parse(packageCreateCall[1].body);
+        expect(packagePayload.name).toEqual("test-dataset");
+        expect(packagePayload.owner_org).toEqual("test-org");
+        expect(packagePayload.title).toEqual("Test Package");
+        expect(packagePayload.notes).toEqual("A test package");
+        expect(packagePayload.resources).toEqual([]);
+        expect(result).toEqual({
+            path: "https://ckan.example.com/dataset/test-dataset",
+            datasetUrl: "https://ckan.example.com/dataset/test-dataset",
+        });
+    });
+    it("creates resources with file uploads", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-1",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-1",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-2",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-2",
+                },
+            }),
+        });
+        await savePackageToCkan(mockPackage, mockOptions);
+        const resourceCreateCall = fetchMock.mock.calls[1];
+        expect(resourceCreateCall).toBeDefined();
+        if (!resourceCreateCall)
+            return;
+        expect(resourceCreateCall[0]).toEqual("https://ckan.example.com/api/3/action/resource_create");
+        expect(resourceCreateCall[1]).toMatchObject({
+            method: "POST",
+            headers: {
+                Authorization: "test-api-key",
+            },
+        });
+        const formData = resourceCreateCall[1].body;
+        expect(formData).toBeInstanceOf(FormData);
+        expect(formData.get("package_id")).toEqual("test-dataset");
+        expect(formData.get("name")).toEqual("data.csv");
+    });
+    it("creates datapackage.json resource", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-1",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-1",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-2",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-2",
+                },
+            }),
+        });
+        await savePackageToCkan(mockPackage, mockOptions);
+        const datapackageCreateCall = fetchMock.mock.calls[2];
+        expect(datapackageCreateCall).toBeDefined();
+        if (!datapackageCreateCall)
+            return;
+        expect(datapackageCreateCall[0]).toEqual("https://ckan.example.com/api/3/action/resource_create");
+        const formData = datapackageCreateCall[1].body;
+        expect(formData).toBeInstanceOf(FormData);
+        expect(formData.get("package_id")).toEqual("test-dataset");
+        expect(formData.get("name")).toEqual("datapackage.json");
+        const uploadBlob = formData.get("upload");
+        expect(uploadBlob).toBeInstanceOf(Blob);
+    });
+    it("handles API errors from package_create", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            statusText: "Bad Request",
+            text: () => Promise.resolve("Invalid package data"),
+        });
+        await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow("CKAN API error: 400 Bad Request");
+    });
+    it("handles API errors from resource_create", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            statusText: "Internal Server Error",
+            text: () => Promise.resolve("Failed to create resource"),
+        });
+        await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow("CKAN API error: 500 Internal Server Error");
+    });
+    it("handles CKAN API success: false responses", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: false,
+                error: {
+                    message: "Package already exists",
+                },
+            }),
+        });
+        await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow("CKAN API error");
+    });
+    it("handles packages with multiple resources", async () => {
+        const multiResourcePackage = {
+            ...mockPackage,
+            resources: [
+                {
+                    name: "resource-1",
+                    path: getFixturePath("data.csv"),
+                    format: "csv",
+                },
+                {
+                    name: "resource-2",
+                    path: getFixturePath("data.csv"),
+                    format: "json",
+                },
+            ],
+        };
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        await savePackageToCkan(multiResourcePackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(4);
+        const secondResourceCall = fetchMock.mock.calls[2];
+        expect(secondResourceCall).toBeDefined();
+        if (!secondResourceCall)
+            return;
+        expect(secondResourceCall[0]).toEqual("https://ckan.example.com/api/3/action/resource_create");
+    });
+    it("handles packages with no resources", async () => {
+        const emptyPackage = {
+            ...mockPackage,
+            resources: [],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    name: "test-dataset",
+                    url: "https://ckan.example.com/dataset/test-dataset",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: {
+                    id: "resource-1",
+                    url: "https://ckan.example.com/dataset/test-dataset/resource/resource-1",
+                },
+            }),
+        });
+        const result = await savePackageToCkan(emptyPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(result.datasetUrl).toEqual("https://ckan.example.com/dataset/test-dataset");
+    });
+    it("passes API key in Authorization header", async () => {
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                success: true,
+                result: { name: "test-dataset" },
+            }),
+        });
+        await savePackageToCkan(mockPackage, {
+            ...mockOptions,
+            apiKey: "custom-api-key",
+        });
+        const firstCall = fetchMock.mock.calls[0];
+        expect(firstCall).toBeDefined();
+        if (!firstCall)
+            return;
+        const headers = firstCall[1].headers;
+        expect(headers.Authorization).toEqual("custom-api-key");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/ckan/package/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative } from \"node:path\"\nimport type { Package } from \"@frictionless-ts/metadata\"\nimport { loadPackageDescriptor } from \"@frictionless-ts/metadata\"\nimport { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\"\nimport { savePackageToCkan } from \"./save.ts\"\n\ndescribe(\"savePackageToCkan\", () => {\n  const getFixturePath = (name: string) =>\n    relative(process.cwd(), `${import.meta.dirname}/fixtures/${name}`)\n\n  const mockPackage: Package = {\n    name: \"test-package\",\n    title: \"Test Package\",\n    description: \"A test package\",\n    version: \"1.0.0\",\n    resources: [\n      {\n        name: \"test-resource\",\n        path: getFixturePath(\"data.csv\"),\n        format: \"csv\",\n        bytes: 100,\n      },\n    ],\n  }\n\n  const mockOptions = {\n    apiKey: \"test-api-key\",\n    ckanUrl: \"https://ckan.example.com\",\n    ownerOrg: \"test-org\",\n    datasetName: \"test-dataset\",\n  }\n\n  const originalFetch = globalThis.fetch\n  let fetchMock: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    fetchMock = vi.fn()\n    // @ts-ignore\n    globalThis.fetch = fetchMock\n  })\n\n  afterEach(() => {\n    globalThis.fetch = originalFetch\n    vi.resetAllMocks()\n  })\n\n  it.skip(\"should save a package\", async () => {\n    const dataPackage = await loadPackageDescriptor(\n      \"core/package/fixtures/package.json\",\n    )\n\n    const result = await savePackageToCkan(dataPackage, {\n      ckanUrl: \"http://localhost:5000/\",\n      apiKey:\n        \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJ1T0Y0VUNybTU5Y0dzdlk3ejhreF9CeC02R0w4RDBOdW9QS0J0WkJFXzlJIiwiaWF0IjoxNzQ3OTI0NDg5fQ.ioGiLlZkm24xHQRBas5X5ig5eU7u_fIjkl4oifGnLaA\",\n      datasetName: \"test\",\n      ownerOrg: \"test\",\n    })\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"creates a package in CKAN with correct API calls\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-1\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-1\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-2\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-2\",\n          },\n        }),\n    })\n\n    const result = await savePackageToCkan(mockPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(3)\n\n    const packageCreateCall = fetchMock.mock.calls[0]\n    expect(packageCreateCall).toBeDefined()\n    if (!packageCreateCall) return\n\n    expect(packageCreateCall[0]).toEqual(\n      \"https://ckan.example.com/api/3/action/package_create\",\n    )\n    expect(packageCreateCall[1]).toMatchObject({\n      method: \"POST\",\n      headers: {\n        Authorization: \"test-api-key\",\n        \"Content-Type\": \"application/json\",\n      },\n    })\n\n    const packagePayload = JSON.parse(packageCreateCall[1].body)\n    expect(packagePayload.name).toEqual(\"test-dataset\")\n    expect(packagePayload.owner_org).toEqual(\"test-org\")\n    expect(packagePayload.title).toEqual(\"Test Package\")\n    expect(packagePayload.notes).toEqual(\"A test package\")\n    expect(packagePayload.resources).toEqual([])\n\n    expect(result).toEqual({\n      path: \"https://ckan.example.com/dataset/test-dataset\",\n      datasetUrl: \"https://ckan.example.com/dataset/test-dataset\",\n    })\n  })\n\n  it(\"creates resources with file uploads\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-1\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-1\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-2\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-2\",\n          },\n        }),\n    })\n\n    await savePackageToCkan(mockPackage, mockOptions)\n\n    const resourceCreateCall = fetchMock.mock.calls[1]\n    expect(resourceCreateCall).toBeDefined()\n    if (!resourceCreateCall) return\n\n    expect(resourceCreateCall[0]).toEqual(\n      \"https://ckan.example.com/api/3/action/resource_create\",\n    )\n    expect(resourceCreateCall[1]).toMatchObject({\n      method: \"POST\",\n      headers: {\n        Authorization: \"test-api-key\",\n      },\n    })\n\n    const formData = resourceCreateCall[1].body\n    expect(formData).toBeInstanceOf(FormData)\n    expect(formData.get(\"package_id\")).toEqual(\"test-dataset\")\n    expect(formData.get(\"name\")).toEqual(\"data.csv\")\n  })\n\n  it(\"creates datapackage.json resource\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-1\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-1\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-2\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-2\",\n          },\n        }),\n    })\n\n    await savePackageToCkan(mockPackage, mockOptions)\n\n    const datapackageCreateCall = fetchMock.mock.calls[2]\n    expect(datapackageCreateCall).toBeDefined()\n    if (!datapackageCreateCall) return\n\n    expect(datapackageCreateCall[0]).toEqual(\n      \"https://ckan.example.com/api/3/action/resource_create\",\n    )\n\n    const formData = datapackageCreateCall[1].body\n    expect(formData).toBeInstanceOf(FormData)\n    expect(formData.get(\"package_id\")).toEqual(\"test-dataset\")\n    expect(formData.get(\"name\")).toEqual(\"datapackage.json\")\n\n    const uploadBlob = formData.get(\"upload\")\n    expect(uploadBlob).toBeInstanceOf(Blob)\n  })\n\n  it(\"handles API errors from package_create\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 400,\n      statusText: \"Bad Request\",\n      text: () => Promise.resolve(\"Invalid package data\"),\n    })\n\n    await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow(\n      \"CKAN API error: 400 Bad Request\",\n    )\n  })\n\n  it(\"handles API errors from resource_create\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 500,\n      statusText: \"Internal Server Error\",\n      text: () => Promise.resolve(\"Failed to create resource\"),\n    })\n\n    await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow(\n      \"CKAN API error: 500 Internal Server Error\",\n    )\n  })\n\n  it(\"handles CKAN API success: false responses\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: false,\n          error: {\n            message: \"Package already exists\",\n          },\n        }),\n    })\n\n    await expect(savePackageToCkan(mockPackage, mockOptions)).rejects.toThrow(\n      \"CKAN API error\",\n    )\n  })\n\n  it(\"handles packages with multiple resources\", async () => {\n    const multiResourcePackage: Package = {\n      ...mockPackage,\n      resources: [\n        {\n          name: \"resource-1\",\n          path: getFixturePath(\"data.csv\"),\n          format: \"csv\",\n        },\n        {\n          name: \"resource-2\",\n          path: getFixturePath(\"data.csv\"),\n          format: \"json\",\n        },\n      ],\n    }\n\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    await savePackageToCkan(multiResourcePackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(4)\n\n    const secondResourceCall = fetchMock.mock.calls[2]\n    expect(secondResourceCall).toBeDefined()\n    if (!secondResourceCall) return\n\n    expect(secondResourceCall[0]).toEqual(\n      \"https://ckan.example.com/api/3/action/resource_create\",\n    )\n  })\n\n  it(\"handles packages with no resources\", async () => {\n    const emptyPackage: Package = {\n      ...mockPackage,\n      resources: [],\n    }\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            name: \"test-dataset\",\n            url: \"https://ckan.example.com/dataset/test-dataset\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: {\n            id: \"resource-1\",\n            url: \"https://ckan.example.com/dataset/test-dataset/resource/resource-1\",\n          },\n        }),\n    })\n\n    const result = await savePackageToCkan(emptyPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(2)\n    expect(result.datasetUrl).toEqual(\n      \"https://ckan.example.com/dataset/test-dataset\",\n    )\n  })\n\n  it(\"passes API key in Authorization header\", async () => {\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          success: true,\n          result: { name: \"test-dataset\" },\n        }),\n    })\n\n    await savePackageToCkan(mockPackage, {\n      ...mockOptions,\n      apiKey: \"custom-api-key\",\n    })\n\n    const firstCall = fetchMock.mock.calls[0]\n    expect(firstCall).toBeDefined()\n    if (!firstCall) return\n\n    const headers = firstCall[1].headers\n    expect(headers.Authorization).toEqual(\"custom-api-key\")\n  })\n})\n"]}

package/build/plugins/ckan/plugin.d.ts

@@ -0,0 +1,19 @@
+import type { DatasetPlugin } from "../../plugin.ts";
+export declare class CkanPlugin implements DatasetPlugin {
+    loadPackage(source: string): Promise<{
+        [x: `${string}:${string}`]: any;
+        $schema?: string;
+        resources: import("@frictionless-ts/metadata").Resource[];
+        name?: string;
+        title?: string;
+        description?: string;
+        homepage?: string;
+        version?: string;
+        licenses?: import("@frictionless-ts/metadata").License[];
+        contributors?: import("@frictionless-ts/metadata").Contributor[];
+        sources?: import("@frictionless-ts/metadata").Source[];
+        keywords?: string[];
+        created?: string;
+        image?: string;
+    } | undefined>;
+}

package/build/plugins/ckan/plugin.js

@@ -0,0 +1,18 @@
+import { isRemotePath } from "@frictionless-ts/metadata";
+import { loadPackageFromCkan } from "./package/load.js";
+export class CkanPlugin {
+    async loadPackage(source) {
+        const isCkan = getIsCkan(source);
+        if (!isCkan)
+            return undefined;
+        const dataPackage = await loadPackageFromCkan(source);
+        return dataPackage;
+    }
+}
+function getIsCkan(path) {
+    const isRemote = isRemotePath(path);
+    if (!isRemote)
+        return false;
+    return path.includes("/dataset/");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2lucy9ja2FuL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFFeEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFFdkQsTUFBTSxPQUFPLFVBQVU7SUFDckIsS0FBSyxDQUFDLFdBQVcsQ0FBQyxNQUFjO1FBQzlCLE1BQU0sTUFBTSxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUNoQyxJQUFJLENBQUMsTUFBTTtZQUFFLE9BQU8sU0FBUyxDQUFBO1FBRTdCLE1BQU0sV0FBVyxHQUFHLE1BQU0sbUJBQW1CLENBQUMsTUFBTSxDQUFDLENBQUE7UUFDckQsT0FBTyxXQUFXLENBQUE7SUFDcEIsQ0FBQztDQUNGO0FBRUQsU0FBUyxTQUFTLENBQUMsSUFBWTtJQUM3QixNQUFNLFFBQVEsR0FBRyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDbkMsSUFBSSxDQUFDLFFBQVE7UUFBRSxPQUFPLEtBQUssQ0FBQTtJQUUzQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUE7QUFDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGlzUmVtb3RlUGF0aCB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgRGF0YXNldFBsdWdpbiB9IGZyb20gXCIuLi8uLi9wbHVnaW4udHNcIlxuaW1wb3J0IHsgbG9hZFBhY2thZ2VGcm9tQ2thbiB9IGZyb20gXCIuL3BhY2thZ2UvbG9hZC50c1wiXG5cbmV4cG9ydCBjbGFzcyBDa2FuUGx1Z2luIGltcGxlbWVudHMgRGF0YXNldFBsdWdpbiB7XG4gIGFzeW5jIGxvYWRQYWNrYWdlKHNvdXJjZTogc3RyaW5nKSB7XG4gICAgY29uc3QgaXNDa2FuID0gZ2V0SXNDa2FuKHNvdXJjZSlcbiAgICBpZiAoIWlzQ2thbikgcmV0dXJuIHVuZGVmaW5lZFxuXG4gICAgY29uc3QgZGF0YVBhY2thZ2UgPSBhd2FpdCBsb2FkUGFja2FnZUZyb21Da2FuKHNvdXJjZSlcbiAgICByZXR1cm4gZGF0YVBhY2thZ2VcbiAgfVxufVxuXG5mdW5jdGlvbiBnZXRJc0NrYW4ocGF0aDogc3RyaW5nKSB7XG4gIGNvbnN0IGlzUmVtb3RlID0gaXNSZW1vdGVQYXRoKHBhdGgpXG4gIGlmICghaXNSZW1vdGUpIHJldHVybiBmYWxzZVxuXG4gIHJldHVybiBwYXRoLmluY2x1ZGVzKFwiL2RhdGFzZXQvXCIpXG59XG4iXX0=

package/build/plugins/ckan/plugin.spec.d.ts

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

package/build/plugins/ckan/plugin.spec.js

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as packageModule from "./package/load.js";
+import { CkanPlugin } from "./plugin.js";
+vi.mock("./package/load.ts", () => ({
+    loadPackageFromCkan: vi.fn(),
+}));
+describe("CkanPlugin", () => {
+    let plugin;
+    let mockLoadPackageFromCkan;
+    beforeEach(() => {
+        plugin = new CkanPlugin();
+        mockLoadPackageFromCkan = vi.mocked(packageModule.loadPackageFromCkan);
+        vi.clearAllMocks();
+    });
+    describe("loadPackage", () => {
+        it("should load package from ckan url with /dataset/ path", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromCkan.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("https://data.example.com/dataset/test-dataset");
+            expect(mockLoadPackageFromCkan).toHaveBeenCalledWith("https://data.example.com/dataset/test-dataset");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for urls without /dataset/", async () => {
+            const result = await plugin.loadPackage("https://example.com/data");
+            expect(mockLoadPackageFromCkan).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for local paths", async () => {
+            const result = await plugin.loadPackage("./data");
+            expect(mockLoadPackageFromCkan).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for github urls", async () => {
+            const result = await plugin.loadPackage("https://github.com/owner/repo");
+            expect(mockLoadPackageFromCkan).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle ckan urls with additional path segments", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromCkan.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("https://data.example.com/dataset/test-dataset/resource/123");
+            expect(mockLoadPackageFromCkan).toHaveBeenCalledWith("https://data.example.com/dataset/test-dataset/resource/123");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should handle ckan urls with query parameters", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromCkan.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("https://data.example.com/dataset/test-dataset?id=456");
+            expect(mockLoadPackageFromCkan).toHaveBeenCalledWith("https://data.example.com/dataset/test-dataset?id=456");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should handle http ckan urls", async () => {
+            const mockPackage = {
+                name: "test-package",
+                resources: [{ name: "test", data: [] }],
+            };
+            mockLoadPackageFromCkan.mockResolvedValue(mockPackage);
+            const result = await plugin.loadPackage("http://data.example.com/dataset/test-dataset");
+            expect(mockLoadPackageFromCkan).toHaveBeenCalledWith("http://data.example.com/dataset/test-dataset");
+            expect(result).toEqual(mockPackage);
+        });
+        it("should return undefined for zenodo urls", async () => {
+            const result = await plugin.loadPackage("https://zenodo.org/record/123");
+            expect(mockLoadPackageFromCkan).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for urls with dataset in query params only", async () => {
+            const result = await plugin.loadPackage("https://example.com/api?name=dataset");
+            expect(mockLoadPackageFromCkan).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.spec.js","sourceRoot":"","sources":["../../../plugins/ckan/plugin.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Package } from \"@frictionless-ts/metadata\"\nimport { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport * as packageModule from \"./package/load.ts\"\nimport { CkanPlugin } from \"./plugin.ts\"\n\nvi.mock(\"./package/load.ts\", () => ({\n  loadPackageFromCkan: vi.fn(),\n}))\n\ndescribe(\"CkanPlugin\", () => {\n  let plugin: CkanPlugin\n  let mockLoadPackageFromCkan: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    plugin = new CkanPlugin()\n    mockLoadPackageFromCkan = vi.mocked(packageModule.loadPackageFromCkan)\n    vi.clearAllMocks()\n  })\n\n  describe(\"loadPackage\", () => {\n    it(\"should load package from ckan url with /dataset/ path\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromCkan.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\n        \"https://data.example.com/dataset/test-dataset\",\n      )\n\n      expect(mockLoadPackageFromCkan).toHaveBeenCalledWith(\n        \"https://data.example.com/dataset/test-dataset\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should return undefined for urls without /dataset/\", async () => {\n      const result = await plugin.loadPackage(\"https://example.com/data\")\n\n      expect(mockLoadPackageFromCkan).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for local paths\", async () => {\n      const result = await plugin.loadPackage(\"./data\")\n\n      expect(mockLoadPackageFromCkan).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for github urls\", async () => {\n      const result = await plugin.loadPackage(\"https://github.com/owner/repo\")\n\n      expect(mockLoadPackageFromCkan).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle ckan urls with additional path segments\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromCkan.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\n        \"https://data.example.com/dataset/test-dataset/resource/123\",\n      )\n\n      expect(mockLoadPackageFromCkan).toHaveBeenCalledWith(\n        \"https://data.example.com/dataset/test-dataset/resource/123\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should handle ckan urls with query parameters\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromCkan.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\n        \"https://data.example.com/dataset/test-dataset?id=456\",\n      )\n\n      expect(mockLoadPackageFromCkan).toHaveBeenCalledWith(\n        \"https://data.example.com/dataset/test-dataset?id=456\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should handle http ckan urls\", async () => {\n      const mockPackage: Package = {\n        name: \"test-package\",\n        resources: [{ name: \"test\", data: [] }],\n      }\n      mockLoadPackageFromCkan.mockResolvedValue(mockPackage)\n\n      const result = await plugin.loadPackage(\n        \"http://data.example.com/dataset/test-dataset\",\n      )\n\n      expect(mockLoadPackageFromCkan).toHaveBeenCalledWith(\n        \"http://data.example.com/dataset/test-dataset\",\n      )\n      expect(result).toEqual(mockPackage)\n    })\n\n    it(\"should return undefined for zenodo urls\", async () => {\n      const result = await plugin.loadPackage(\"https://zenodo.org/record/123\")\n\n      expect(mockLoadPackageFromCkan).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for urls with dataset in query params only\", async () => {\n      const result = await plugin.loadPackage(\n        \"https://example.com/api?name=dataset\",\n      )\n\n      expect(mockLoadPackageFromCkan).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n})\n"]}