@frictionless-ts/dataset 1.0.1

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

@@ -0,0 +1,524 @@
+import { relative } from "node:path";
+import { loadPackageDescriptor } from "@frictionless-ts/metadata";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { savePackageToZenodo } from "./save.js";
+describe("savePackageToZenodo", () => {
+    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",
+        sandbox: true,
+    };
+    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 savePackageToZenodo(dataPackage, {
+            apiKey: "<key>",
+            sandbox: true,
+        });
+        expect(result).toBeDefined();
+    });
+    it("creates a deposition in Zenodo with correct API calls", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "data.csv",
+                filesize: 100,
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-2",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        const result = await savePackageToZenodo(mockPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        const depositionCreateCall = fetchMock.mock.calls[0];
+        expect(depositionCreateCall).toBeDefined();
+        if (!depositionCreateCall)
+            return;
+        expect(depositionCreateCall[0]).toContain("https://sandbox.zenodo.org/api/deposit/depositions");
+        expect(depositionCreateCall[0]).toContain("access_token=test-api-key");
+        expect(depositionCreateCall[1]).toMatchObject({
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const depositionPayload = JSON.parse(depositionCreateCall[1].body);
+        expect(depositionPayload.metadata.title).toEqual("Test Package");
+        expect(depositionPayload.metadata.description).toEqual("A test package");
+        expect(result).toEqual({
+            path: "https://sandbox.zenodo.org/records/12345/files/datapackage.json",
+            datasetUrl: "https://sandbox.zenodo.org/uploads/12345",
+        });
+    });
+    it("uploads resource files to deposition", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "data.csv",
+                filesize: 100,
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-2",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        await savePackageToZenodo(mockPackage, mockOptions);
+        const fileUploadCall = fetchMock.mock.calls[1];
+        expect(fileUploadCall).toBeDefined();
+        if (!fileUploadCall)
+            return;
+        expect(fileUploadCall[0]).toContain("https://sandbox.zenodo.org/api/deposit/depositions/12345/files");
+        expect(fileUploadCall[0]).toContain("access_token=test-api-key");
+        expect(fileUploadCall[1]).toMatchObject({
+            method: "POST",
+        });
+        const formData = fileUploadCall[1].body;
+        expect(formData).toBeInstanceOf(FormData);
+    });
+    it("uploads datapackage.json metadata file", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "data.csv",
+                filesize: 100,
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-2",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        await savePackageToZenodo(mockPackage, mockOptions);
+        const datapackageUploadCall = fetchMock.mock.calls[2];
+        expect(datapackageUploadCall).toBeDefined();
+        if (!datapackageUploadCall)
+            return;
+        expect(datapackageUploadCall[0]).toContain("https://sandbox.zenodo.org/api/deposit/depositions/12345/files");
+        const formData = datapackageUploadCall[1].body;
+        expect(formData).toBeInstanceOf(FormData);
+        const fileBlob = formData.get("file");
+        expect(fileBlob).toBeInstanceOf(Blob);
+    });
+    it("uses production API when sandbox is false", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://zenodo.org/api/deposit/depositions/12345",
+                    html: "https://zenodo.org/deposit/12345",
+                    files: "https://zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "data.csv",
+            }),
+        });
+        await savePackageToZenodo(mockPackage, {
+            apiKey: "test-api-key",
+            sandbox: false,
+        });
+        const depositionCreateCall = fetchMock.mock.calls[0];
+        expect(depositionCreateCall).toBeDefined();
+        if (!depositionCreateCall)
+            return;
+        expect(depositionCreateCall[0]).toContain("https://zenodo.org/api");
+        expect(depositionCreateCall[0]).not.toContain("sandbox");
+    });
+    it("passes API key as access_token query parameter", async () => {
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        await savePackageToZenodo(mockPackage, {
+            apiKey: "custom-api-key",
+            sandbox: true,
+        });
+        const depositionCreateCall = fetchMock.mock.calls[0];
+        expect(depositionCreateCall).toBeDefined();
+        if (!depositionCreateCall)
+            return;
+        expect(depositionCreateCall[0]).toContain("access_token=custom-api-key");
+    });
+    it("handles API errors from deposition creation", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            statusText: "Bad Request",
+            text: () => Promise.resolve("Invalid deposition data"),
+        });
+        await expect(savePackageToZenodo(mockPackage, mockOptions)).rejects.toThrow("Zenodo API error: 400 Bad Request");
+    });
+    it("handles API errors from file upload", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            statusText: "Internal Server Error",
+            text: () => Promise.resolve("Failed to upload file"),
+        });
+        await expect(savePackageToZenodo(mockPackage, mockOptions)).rejects.toThrow("Zenodo API error: 500 Internal Server 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({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        await savePackageToZenodo(multiResourcePackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(4);
+        const secondFileUploadCall = fetchMock.mock.calls[2];
+        expect(secondFileUploadCall).toBeDefined();
+        if (!secondFileUploadCall)
+            return;
+        expect(secondFileUploadCall[0]).toContain("/files");
+    });
+    it("handles packages with no resources", async () => {
+        const emptyPackage = {
+            ...mockPackage,
+            resources: [],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        const result = await savePackageToZenodo(emptyPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(result.datasetUrl).toEqual("https://sandbox.zenodo.org/uploads/12345");
+    });
+    it("skips resources without path", async () => {
+        const packageWithoutPath = {
+            ...mockPackage,
+            resources: [
+                {
+                    name: "resource-without-path",
+                    format: "csv",
+                },
+            ],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        await savePackageToZenodo(packageWithoutPath, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+    });
+    it("includes contributors with author role as creators in metadata", async () => {
+        const packageWithContributors = {
+            ...mockPackage,
+            contributors: [
+                {
+                    title: "Alice Smith",
+                    role: "author",
+                    path: "University of Example",
+                },
+                {
+                    title: "Bob Jones",
+                    role: "author",
+                    path: "Institute of Testing",
+                },
+                {
+                    title: "Charlie Brown",
+                    role: "contributor",
+                },
+            ],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                links: {
+                    self: "https://sandbox.zenodo.org/api/deposit/depositions/12345",
+                    html: "https://sandbox.zenodo.org/deposit/12345",
+                    files: "https://sandbox.zenodo.org/api/deposit/depositions/12345/files",
+                    bucket: "https://sandbox.zenodo.org/api/files/bucket-id",
+                },
+                metadata: {
+                    title: "Test Package",
+                    description: "A test package",
+                    upload_type: "dataset",
+                    creators: [
+                        {
+                            name: "Alice Smith",
+                            affiliation: "University of Example",
+                        },
+                        {
+                            name: "Bob Jones",
+                            affiliation: "Institute of Testing",
+                        },
+                    ],
+                },
+                state: "unsubmitted",
+                submitted: false,
+                files: [],
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-1",
+                filename: "data.csv",
+                filesize: 100,
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: "file-2",
+                filename: "datapackage.json",
+                filesize: 500,
+            }),
+        });
+        await savePackageToZenodo(packageWithContributors, mockOptions);
+        const depositionCreateCall = fetchMock.mock.calls[0];
+        expect(depositionCreateCall).toBeDefined();
+        if (!depositionCreateCall)
+            return;
+        const depositionPayload = JSON.parse(depositionCreateCall[1].body);
+        expect(depositionPayload.metadata.creators).toEqual([
+            {
+                name: "Alice Smith",
+                affiliation: "University of Example",
+            },
+            {
+                name: "Bob Jones",
+                affiliation: "Institute of Testing",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/zenodo/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 { savePackageToZenodo } from \"./save.ts\"\n\ndescribe(\"savePackageToZenodo\", () => {\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    sandbox: true,\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 savePackageToZenodo(dataPackage, {\n      apiKey: \"<key>\",\n      sandbox: true,\n    })\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"creates a deposition in Zenodo with correct API calls\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"data.csv\",\n          filesize: 100,\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-2\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    const result = await savePackageToZenodo(mockPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(3)\n\n    const depositionCreateCall = fetchMock.mock.calls[0]\n    expect(depositionCreateCall).toBeDefined()\n    if (!depositionCreateCall) return\n\n    expect(depositionCreateCall[0]).toContain(\n      \"https://sandbox.zenodo.org/api/deposit/depositions\",\n    )\n    expect(depositionCreateCall[0]).toContain(\"access_token=test-api-key\")\n    expect(depositionCreateCall[1]).toMatchObject({\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n    })\n\n    const depositionPayload = JSON.parse(depositionCreateCall[1].body)\n    expect(depositionPayload.metadata.title).toEqual(\"Test Package\")\n    expect(depositionPayload.metadata.description).toEqual(\"A test package\")\n\n    expect(result).toEqual({\n      path: \"https://sandbox.zenodo.org/records/12345/files/datapackage.json\",\n      datasetUrl: \"https://sandbox.zenodo.org/uploads/12345\",\n    })\n  })\n\n  it(\"uploads resource files to deposition\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"data.csv\",\n          filesize: 100,\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-2\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    await savePackageToZenodo(mockPackage, mockOptions)\n\n    const fileUploadCall = fetchMock.mock.calls[1]\n    expect(fileUploadCall).toBeDefined()\n    if (!fileUploadCall) return\n\n    expect(fileUploadCall[0]).toContain(\n      \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n    )\n    expect(fileUploadCall[0]).toContain(\"access_token=test-api-key\")\n    expect(fileUploadCall[1]).toMatchObject({\n      method: \"POST\",\n    })\n\n    const formData = fileUploadCall[1].body\n    expect(formData).toBeInstanceOf(FormData)\n  })\n\n  it(\"uploads datapackage.json metadata file\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"data.csv\",\n          filesize: 100,\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-2\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    await savePackageToZenodo(mockPackage, mockOptions)\n\n    const datapackageUploadCall = fetchMock.mock.calls[2]\n    expect(datapackageUploadCall).toBeDefined()\n    if (!datapackageUploadCall) return\n\n    expect(datapackageUploadCall[0]).toContain(\n      \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n    )\n\n    const formData = datapackageUploadCall[1].body\n    expect(formData).toBeInstanceOf(FormData)\n\n    const fileBlob = formData.get(\"file\")\n    expect(fileBlob).toBeInstanceOf(Blob)\n  })\n\n  it(\"uses production API when sandbox is false\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://zenodo.org/deposit/12345\",\n            files: \"https://zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"data.csv\",\n        }),\n    })\n\n    await savePackageToZenodo(mockPackage, {\n      apiKey: \"test-api-key\",\n      sandbox: false,\n    })\n\n    const depositionCreateCall = fetchMock.mock.calls[0]\n    expect(depositionCreateCall).toBeDefined()\n    if (!depositionCreateCall) return\n\n    expect(depositionCreateCall[0]).toContain(\"https://zenodo.org/api\")\n    expect(depositionCreateCall[0]).not.toContain(\"sandbox\")\n  })\n\n  it(\"passes API key as access_token query parameter\", async () => {\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    await savePackageToZenodo(mockPackage, {\n      apiKey: \"custom-api-key\",\n      sandbox: true,\n    })\n\n    const depositionCreateCall = fetchMock.mock.calls[0]\n    expect(depositionCreateCall).toBeDefined()\n    if (!depositionCreateCall) return\n\n    expect(depositionCreateCall[0]).toContain(\"access_token=custom-api-key\")\n  })\n\n  it(\"handles API errors from deposition creation\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 400,\n      statusText: \"Bad Request\",\n      text: () => Promise.resolve(\"Invalid deposition data\"),\n    })\n\n    await expect(savePackageToZenodo(mockPackage, mockOptions)).rejects.toThrow(\n      \"Zenodo API error: 400 Bad Request\",\n    )\n  })\n\n  it(\"handles API errors from file upload\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 500,\n      statusText: \"Internal Server Error\",\n      text: () => Promise.resolve(\"Failed to upload file\"),\n    })\n\n    await expect(savePackageToZenodo(mockPackage, mockOptions)).rejects.toThrow(\n      \"Zenodo API error: 500 Internal Server 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          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    await savePackageToZenodo(multiResourcePackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(4)\n\n    const secondFileUploadCall = fetchMock.mock.calls[2]\n    expect(secondFileUploadCall).toBeDefined()\n    if (!secondFileUploadCall) return\n\n    expect(secondFileUploadCall[0]).toContain(\"/files\")\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          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    const result = await savePackageToZenodo(emptyPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(2)\n    expect(result.datasetUrl).toEqual(\n      \"https://sandbox.zenodo.org/uploads/12345\",\n    )\n  })\n\n  it(\"skips resources without path\", async () => {\n    const packageWithoutPath: Package = {\n      ...mockPackage,\n      resources: [\n        {\n          name: \"resource-without-path\",\n          format: \"csv\",\n        },\n      ],\n    }\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    await savePackageToZenodo(packageWithoutPath, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(2)\n  })\n\n  it(\"includes contributors with author role as creators in metadata\", async () => {\n    const packageWithContributors: Package = {\n      ...mockPackage,\n      contributors: [\n        {\n          title: \"Alice Smith\",\n          role: \"author\",\n          path: \"University of Example\",\n        },\n        {\n          title: \"Bob Jones\",\n          role: \"author\",\n          path: \"Institute of Testing\",\n        },\n        {\n          title: \"Charlie Brown\",\n          role: \"contributor\",\n        },\n      ],\n    }\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          links: {\n            self: \"https://sandbox.zenodo.org/api/deposit/depositions/12345\",\n            html: \"https://sandbox.zenodo.org/deposit/12345\",\n            files:\n              \"https://sandbox.zenodo.org/api/deposit/depositions/12345/files\",\n            bucket: \"https://sandbox.zenodo.org/api/files/bucket-id\",\n          },\n          metadata: {\n            title: \"Test Package\",\n            description: \"A test package\",\n            upload_type: \"dataset\",\n            creators: [\n              {\n                name: \"Alice Smith\",\n                affiliation: \"University of Example\",\n              },\n              {\n                name: \"Bob Jones\",\n                affiliation: \"Institute of Testing\",\n              },\n            ],\n          },\n          state: \"unsubmitted\",\n          submitted: false,\n          files: [],\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-1\",\n          filename: \"data.csv\",\n          filesize: 100,\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: \"file-2\",\n          filename: \"datapackage.json\",\n          filesize: 500,\n        }),\n    })\n\n    await savePackageToZenodo(packageWithContributors, mockOptions)\n\n    const depositionCreateCall = fetchMock.mock.calls[0]\n    expect(depositionCreateCall).toBeDefined()\n    if (!depositionCreateCall) return\n\n    const depositionPayload = JSON.parse(depositionCreateCall[1].body)\n    expect(depositionPayload.metadata.creators).toEqual([\n      {\n        name: \"Alice Smith\",\n        affiliation: \"University of Example\",\n      },\n      {\n        name: \"Bob Jones\",\n        affiliation: \"Institute of Testing\",\n      },\n    ])\n  })\n})\n"]}

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

@@ -0,0 +1,19 @@
+import type { DatasetPlugin } from "../../plugin.ts";
+export declare class ZenodoPlugin 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/zenodo/plugin.js

@@ -0,0 +1,18 @@
+import { isRemotePath } from "@frictionless-ts/metadata";
+import { loadPackageFromZenodo } from "./package/load.js";
+export class ZenodoPlugin {
+    async loadPackage(source) {
+        const isZenodo = getIsZenodo(source);
+        if (!isZenodo)
+            return undefined;
+        const dataPackage = await loadPackageFromZenodo(source);
+        return dataPackage;
+    }
+}
+function getIsZenodo(path) {
+    const isRemote = isRemotePath(path);
+    if (!isRemote)
+        return false;
+    return new URL(path).hostname.endsWith("zenodo.org");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2lucy96ZW5vZG8vcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUV4RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUV6RCxNQUFNLE9BQU8sWUFBWTtJQUN2QixLQUFLLENBQUMsV0FBVyxDQUFDLE1BQWM7UUFDOUIsTUFBTSxRQUFRLEdBQUcsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBQ3BDLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFFL0IsTUFBTSxXQUFXLEdBQUcsTUFBTSxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUN2RCxPQUFPLFdBQVcsQ0FBQTtJQUNwQixDQUFDO0NBQ0Y7QUFFRCxTQUFTLFdBQVcsQ0FBQyxJQUFZO0lBQy9CLE1BQU0sUUFBUSxHQUFHLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUNuQyxJQUFJLENBQUMsUUFBUTtRQUFFLE9BQU8sS0FBSyxDQUFBO0lBRTNCLE9BQU8sSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsQ0FBQTtBQUN0RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNSZW1vdGVQYXRoIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBEYXRhc2V0UGx1Z2luIH0gZnJvbSBcIi4uLy4uL3BsdWdpbi50c1wiXG5pbXBvcnQgeyBsb2FkUGFja2FnZUZyb21aZW5vZG8gfSBmcm9tIFwiLi9wYWNrYWdlL2xvYWQudHNcIlxuXG5leHBvcnQgY2xhc3MgWmVub2RvUGx1Z2luIGltcGxlbWVudHMgRGF0YXNldFBsdWdpbiB7XG4gIGFzeW5jIGxvYWRQYWNrYWdlKHNvdXJjZTogc3RyaW5nKSB7XG4gICAgY29uc3QgaXNaZW5vZG8gPSBnZXRJc1plbm9kbyhzb3VyY2UpXG4gICAgaWYgKCFpc1plbm9kbykgcmV0dXJuIHVuZGVmaW5lZFxuXG4gICAgY29uc3QgZGF0YVBhY2thZ2UgPSBhd2FpdCBsb2FkUGFja2FnZUZyb21aZW5vZG8oc291cmNlKVxuICAgIHJldHVybiBkYXRhUGFja2FnZVxuICB9XG59XG5cbmZ1bmN0aW9uIGdldElzWmVub2RvKHBhdGg6IHN0cmluZykge1xuICBjb25zdCBpc1JlbW90ZSA9IGlzUmVtb3RlUGF0aChwYXRoKVxuICBpZiAoIWlzUmVtb3RlKSByZXR1cm4gZmFsc2VcblxuICByZXR1cm4gbmV3IFVSTChwYXRoKS5ob3N0bmFtZS5lbmRzV2l0aChcInplbm9kby5vcmdcIilcbn1cbiJdfQ==

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

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