@biblioteksentralen/oai-pmh-client 0.0.1

package/README.md

@@ -0,0 +1,37 @@
+# `@biblioteksentralen/oai-pmh-client`
+
+## Usage
+
+```ts
+import { OaiPmhClient } from "@biblioteksentralen/oai-pmh-client";
+import { pino } from "pino";
+
+const log = pino(); // Any logger implementing the TypeScript Abstract Logger interface can be used.
+
+const oaiPmhClient = new OaiPmhClient({
+  url: "https://stord.bib.no/cgi-bin/oai",
+  metadataPrefix: "marc21",
+  log,
+});
+
+const options = { from: "2023-05-10" };
+for await (const { record } of oaiPmhClient.listRecords(options)) {
+  console.log(`Fetched record ${record.header.identifier}`);
+  // doSomethingWithRecord(response.record)
+}
+```
+
+The `listRecords()` method is implemented as an async generator and handles resumption and automatic retries under the hood. Custom timeout and retry options can be set when constructing the client. For example, to disable automatic retries, set `attempts` to `1`:
+
+```ts
+const oaiPmhClient = new OaiPmhClient({
+  url: "https://stord.bib.no/cgi-bin/oai",
+  metadataPrefix: "marc21",
+  log,
+  retry: { attempts: 1 },
+});
+```
+
+## Error handling
+
+If we receive an error from the OAI-PMH server, a `OaiPmhError` error will be raised, containing the [OAI-PMH error](http://www.openarchives.org/OAI/openarchivesprotocol.html#ErrorConditions). These are typically returned for invalid argument values or other client errors.

package/dist/index.d.ts

@@ -0,0 +1,161 @@
+import { Logger } from 'ts-log';
+import { z } from 'zod';
+import { XmlElement } from '@biblioteksentralen/marc';
+
+interface RetryOptions {
+    /**
+     * Number of times to try running the function. Setting this to 1 means to not retry.
+     */
+    attempts?: number;
+    /**
+     * Delay can be specified either as constant number of milliseconds or as a function
+     * that returns the number of milliseconds based on the attempt number.
+     */
+    delay?: number | ((attempt: number) => number);
+    /**
+     * Callback function to be called on each retry. Can be used e.g. to conditionally
+     * abort retrying or do logging. If the function returns true, the retry will be aborted.
+     */
+    onRetry?: (props: {
+        error: Error;
+        attempt: number;
+        delay: number;
+    }) => Promise<boolean | void> | boolean | void;
+}
+interface BackoffOptions {
+    randomize?: boolean;
+    min?: number;
+    max?: number;
+    factor?: number;
+}
+/**
+ * Exponential fallback function that can be passed to retry.
+ **/
+declare const exponentialBackoff: ({ min, max, factor, randomize, }?: BackoffOptions) => (attempt: number) => number;
+
+type RequestParams = {
+    metadataPrefix?: string;
+    set?: string;
+    identifier?: string;
+    resumptionToken?: string;
+    verb?: "ListRecords" | "ListSets" | "ListMetadataFormats" | "ListIdentifiers" | "GetRecord";
+};
+declare const OaiPmhHeader: z.ZodObject<{
+    identifier: z.ZodString;
+    deleted: z.ZodBoolean;
+    datestamp: z.ZodDate;
+    setSpec: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+    deleted: boolean;
+    datestamp: Date;
+    setSpec: string[];
+}, {
+    identifier: string;
+    deleted: boolean;
+    datestamp: Date;
+    setSpec: string[];
+}>;
+type OaiPmhHeader = z.infer<typeof OaiPmhHeader>;
+declare const OaiPmhSet: z.ZodObject<{
+    setSpec: z.ZodString;
+    setName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    setSpec: string;
+    setName: string;
+}, {
+    setSpec: string;
+    setName: string;
+}>;
+type OaiPmhSet = z.infer<typeof OaiPmhSet>;
+type OaiPmhRecord = {
+    header: OaiPmhHeader;
+    metadata: XmlElement | undefined;
+};
+type ListRecordsParams = {
+    metadataPrefix?: string;
+    resumptionToken?: string;
+    from?: string;
+    until?: string;
+    set?: string;
+};
+type OaiPmhClientConfig = {
+    url: string;
+    log?: Logger;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    retry?: RetryOptions;
+    metadataPrefix?: string;
+    set?: string;
+    retryOnOaiPmhError?: boolean;
+};
+
+/**
+ * Error thrown when the OAI-PMH server returns an error response.
+ * Ref: http://www.openarchives.org/OAI/openarchivesprotocol.html#ErrorConditions
+ * There is usually no point in retrying when we get one of these.
+ */
+declare class OaiPmhError extends Error {
+    name: string;
+    code: string;
+    description?: string;
+    constructor({ code, description }: {
+        code: string;
+        description?: string;
+    });
+}
+/**
+ * Error thrown when we receive a response with a status code >= 400, but not 404.
+ */
+declare class HttpError extends Error {
+    response: Response;
+    name: string;
+    constructor(response: Response, msg?: string);
+}
+
+type OaiPmhResponse = {
+    records: OaiPmhRecord[];
+    resumptionToken?: string;
+};
+declare const parseListRecordsResponse: (doc: XmlElement) => OaiPmhResponse & {
+    error?: OaiPmhError | undefined;
+};
+type ListSetsResponse = {
+    sets: OaiPmhSet[];
+    error?: OaiPmhError;
+};
+declare const parseListSetsResponse: (doc: XmlElement) => ListSetsResponse;
+declare class OaiPmhClient {
+    url: string;
+    metadataPrefix?: string;
+    set?: string;
+    log: Logger;
+    headers: Record<string, string>;
+    retryOptions: RetryOptions;
+    retryOnOaiPmhError: boolean;
+    timeoutMs: number;
+    constructor(config: OaiPmhClientConfig);
+    request(params: RequestParams): Promise<Response>;
+    private parseXmlResponse;
+    listRecordBatches({ resumptionToken, ...params }?: ListRecordsParams): AsyncGenerator<OaiPmhResponse>;
+    listRecords(params?: ListRecordsParams): AsyncGenerator<ListRecordsResponse>;
+    getRecord(recordId: string): Promise<{
+        record: {
+            header: {
+                identifier: string;
+                deleted: boolean;
+                datestamp: Date;
+                setSpec: string[];
+            };
+            metadata: XmlElement | undefined;
+        } | undefined;
+        error: OaiPmhError | undefined;
+    }>;
+    listSets(): Promise<ListSetsResponse>;
+}
+interface ListRecordsResponse {
+    record: OaiPmhRecord;
+    resumptionToken: string | undefined;
+}
+
+export { HttpError, type ListRecordsParams, type ListRecordsResponse, OaiPmhClient, type OaiPmhClientConfig, OaiPmhError, OaiPmhHeader, type OaiPmhRecord, OaiPmhSet, type RequestParams, exponentialBackoff, parseListRecordsResponse, parseListSetsResponse };

package/dist/index.js

@@ -0,0 +1,293 @@
+'use strict';
+
+var radash = require('radash');
+var tsLog = require('ts-log');
+var url = require('url');
+var zod = require('zod');
+var marc = require('@biblioteksentralen/marc');
+
+// src/OaiPmhClient.ts
+var OaiPmhHeader = zod.z.object({
+  identifier: zod.z.string(),
+  deleted: zod.z.boolean(),
+  datestamp: zod.z.date(),
+  setSpec: zod.z.array(zod.z.string())
+});
+var OaiPmhSet = zod.z.object({
+  setSpec: zod.z.string(),
+  setName: zod.z.string()
+});
+
+// src/errors.ts
+var OaiPmhError = class extends Error {
+  name = "OaiPmhError";
+  code;
+  description;
+  constructor({ code, description }) {
+    super(
+      `OAI-PMH server returned error response: ${code}${description ? ` - ${description}` : ""}`
+    );
+    this.code = code;
+    this.description = description;
+  }
+};
+var HttpError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  name = "HttpError";
+};
+
+// src/util/retry.ts
+var retry = async (func, { attempts = 3, delay = 500, onRetry } = {}) => {
+  for (const attempt of range(1, attempts)) {
+    try {
+      return await func();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw new TypeError(
+          `Non-error was thrown: "${String(
+            error
+          )}". You should only throw errors.`
+        );
+      }
+      if (error instanceof AbortRetry)
+        throw error._error;
+      if (attempt === attempts)
+        throw error;
+      const resolvedDelay = delay instanceof Function ? delay(attempt) : delay;
+      if (onRetry) {
+        const shouldAbort = await onRetry({
+          error,
+          attempt,
+          delay: resolvedDelay
+        });
+        if (shouldAbort === true)
+          throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, resolvedDelay));
+    }
+  }
+  throw new Error("Congratulations, you reached supposedly unreachable code");
+};
+var exponentialBackoff = ({
+  min = 500,
+  max = 3e4,
+  factor = 2,
+  randomize = false
+} = {}) => (attempt) => {
+  const randomFactor = randomize ? Math.random() + 1 : 1;
+  const delay = Math.round(
+    randomFactor * Math.max(min, 1) * Math.pow(factor, attempt)
+  );
+  return Math.min(delay, max);
+};
+var AbortRetry = class extends Error {
+  name = "AbortRetry";
+  _error;
+  constructor(error) {
+    super();
+    this._error = error;
+  }
+};
+function range(start, end) {
+  return [...Array(end - start + 1).keys()].map((i) => i + start);
+}
+
+// src/util/fetchWithTimeout.ts
+async function fetchWithTimeout(input, init = {}, timeout = 6e4) {
+  try {
+    return await fetch(input, {
+      ...init,
+      signal: AbortSignal.timeout(timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new TimeoutError(`Request timed out after ${timeout} ms`);
+    }
+    throw error;
+  }
+}
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+};
+
+// src/OaiPmhClient.ts
+var parseDatestamp = (datestamp) => {
+  if (!datestamp)
+    return void 0;
+  if (datestamp.match(/^\d{4}-\d{2}-\d{2}$/)) {
+    return /* @__PURE__ */ new Date(`${datestamp}T00:00:00Z`);
+  }
+  if (datestamp.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/)) {
+    return new Date(datestamp);
+  }
+  throw new Error(`Unknown datestamp format: ${datestamp}`);
+};
+var parseErrorResponse = (doc) => {
+  const errorElement = doc.elements("/oai:OAI-PMH/oai:error")[0];
+  return errorElement ? new OaiPmhError({
+    // Ref: http://www.openarchives.org/OAI/openarchivesprotocol.html#ErrorConditions
+    code: errorElement.attr("code") ?? "noErrorCode",
+    description: errorElement.text()
+  }) : void 0;
+};
+var parseOaiPmhRecord = (record) => ({
+  header: OaiPmhHeader.parse({
+    identifier: record.text("oai:header/oai:identifier"),
+    deleted: record.elements("oai:header")[0]?.attr("status") === "deleted",
+    datestamp: parseDatestamp(record.text("oai:header/oai:datestamp")),
+    setSpec: record.elements("oai:header/oai:setSpec").map((node) => node.text())
+  }),
+  metadata: record.elements("oai:metadata/*")[0]
+});
+var parseListRecordsResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const resumptionToken = doc.text(
+    "/oai:OAI-PMH/oai:ListRecords/oai:resumptionToken"
+  );
+  const records = doc.elements("/oai:OAI-PMH/oai:ListRecords/oai:record").map(parseOaiPmhRecord);
+  return { error, resumptionToken, records };
+};
+var parseListSetsResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const sets = doc.elements("/oai:OAI-PMH/oai:ListSets/oai:set").map(
+    (element) => OaiPmhSet.parse({
+      setSpec: element.text("oai:setSpec"),
+      setName: element.text("oai:setName")
+    })
+  );
+  return { error, sets };
+};
+var parseGetRecordResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const records = doc.elements("/oai:OAI-PMH/oai:GetRecord/oai:record").map(parseOaiPmhRecord);
+  return { error, records };
+};
+var OaiPmhClient = class {
+  url;
+  metadataPrefix;
+  set;
+  log;
+  headers;
+  retryOptions;
+  retryOnOaiPmhError;
+  timeoutMs;
+  constructor(config) {
+    this.url = config.url;
+    this.log = config.log ?? tsLog.dummyLogger;
+    this.metadataPrefix = config.metadataPrefix;
+    this.set = config.set;
+    this.headers = config.headers ?? {};
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+    this.retryOptions = {
+      attempts: config.retry?.attempts ?? 10,
+      delay: config.retry?.delay ?? exponentialBackoff({ min: 2e3, max: 3e4 }),
+      onRetry: config.retry?.onRetry ?? void 0
+    };
+    this.retryOnOaiPmhError = config.retryOnOaiPmhError ?? false;
+  }
+  async request(params) {
+    const searchParams = new url.URLSearchParams(radash.shake({ ...params }));
+    const url$1 = `${this.url}?${searchParams.toString()}`;
+    this.log.debug(`OAI-PMH request: ${url$1}`);
+    const response = await fetchWithTimeout(
+      url$1,
+      {
+        headers: {
+          "User-Agent": "bs-metadata-oai-harvester/0.1.0 (Biblioteksentralen; drift@bibsent.no)",
+          ...this.headers
+        }
+      },
+      this.timeoutMs
+    );
+    if (response.status === 404) {
+      throw new AbortRetry(
+        new HttpError(
+          response,
+          `OAI-PMH endpoint does not exist (got ${response.status} response)`
+        )
+      );
+    }
+    if (!response.ok) {
+      const responseText = await response.text();
+      throw new HttpError(
+        response,
+        `Request failed with ${response.status} response: ${responseText}`
+      );
+    }
+    return response;
+  }
+  parseXmlResponse(response) {
+    return marc.parseXml(response, {
+      log: this.log,
+      namespaces: {
+        oai: "http://www.openarchives.org/OAI/2.0/"
+      }
+    });
+  }
+  async *listRecordBatches({
+    resumptionToken,
+    ...params
+  } = {}) {
+    do {
+      const result = await retry(async () => {
+        const response = await this.request(
+          resumptionToken ? { verb: "ListRecords", resumptionToken } : {
+            verb: "ListRecords",
+            metadataPrefix: this.metadataPrefix,
+            set: this.set,
+            ...params
+          }
+        );
+        const responseText = await response.text();
+        const responseXml = this.parseXmlResponse(responseText);
+        const listResponse = parseListRecordsResponse(responseXml);
+        if (listResponse.error && this.retryOnOaiPmhError) {
+          throw new OaiPmhError(listResponse.error);
+        }
+        return listResponse;
+      }, this.retryOptions);
+      if (result.error) {
+        throw new OaiPmhError(result.error);
+      }
+      yield result;
+      resumptionToken = result.resumptionToken;
+    } while (resumptionToken);
+  }
+  async *listRecords(params = {}) {
+    for await (const response of this.listRecordBatches(params)) {
+      const { records, resumptionToken } = response;
+      for (const record of records) {
+        yield { record, resumptionToken };
+      }
+    }
+  }
+  async getRecord(recordId) {
+    const response = await this.request({
+      verb: "GetRecord",
+      metadataPrefix: this.metadataPrefix,
+      identifier: recordId
+    });
+    const responseText = await response.text();
+    const responseXml = this.parseXmlResponse(responseText);
+    const { records, error } = parseGetRecordResponse(responseXml);
+    return { record: records[0], error };
+  }
+  async listSets() {
+    const response = await this.request({ verb: "ListSets" });
+    const responseText = await response.text();
+    const responseXml = this.parseXmlResponse(responseText);
+    return parseListSetsResponse(responseXml);
+  }
+};
+
+exports.HttpError = HttpError;
+exports.OaiPmhClient = OaiPmhClient;
+exports.OaiPmhError = OaiPmhError;
+exports.OaiPmhHeader = OaiPmhHeader;
+exports.OaiPmhSet = OaiPmhSet;
+exports.exponentialBackoff = exponentialBackoff;
+exports.parseListRecordsResponse = parseListRecordsResponse;
+exports.parseListSetsResponse = parseListSetsResponse;

package/dist/index.mjs

@@ -0,0 +1,284 @@
+import { shake } from 'radash';
+import { dummyLogger } from 'ts-log';
+import { URLSearchParams } from 'url';
+import { z } from 'zod';
+import { parseXml } from '@biblioteksentralen/marc';
+
+// src/OaiPmhClient.ts
+var OaiPmhHeader = z.object({
+  identifier: z.string(),
+  deleted: z.boolean(),
+  datestamp: z.date(),
+  setSpec: z.array(z.string())
+});
+var OaiPmhSet = z.object({
+  setSpec: z.string(),
+  setName: z.string()
+});
+
+// src/errors.ts
+var OaiPmhError = class extends Error {
+  name = "OaiPmhError";
+  code;
+  description;
+  constructor({ code, description }) {
+    super(
+      `OAI-PMH server returned error response: ${code}${description ? ` - ${description}` : ""}`
+    );
+    this.code = code;
+    this.description = description;
+  }
+};
+var HttpError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  name = "HttpError";
+};
+
+// src/util/retry.ts
+var retry = async (func, { attempts = 3, delay = 500, onRetry } = {}) => {
+  for (const attempt of range(1, attempts)) {
+    try {
+      return await func();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw new TypeError(
+          `Non-error was thrown: "${String(
+            error
+          )}". You should only throw errors.`
+        );
+      }
+      if (error instanceof AbortRetry)
+        throw error._error;
+      if (attempt === attempts)
+        throw error;
+      const resolvedDelay = delay instanceof Function ? delay(attempt) : delay;
+      if (onRetry) {
+        const shouldAbort = await onRetry({
+          error,
+          attempt,
+          delay: resolvedDelay
+        });
+        if (shouldAbort === true)
+          throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, resolvedDelay));
+    }
+  }
+  throw new Error("Congratulations, you reached supposedly unreachable code");
+};
+var exponentialBackoff = ({
+  min = 500,
+  max = 3e4,
+  factor = 2,
+  randomize = false
+} = {}) => (attempt) => {
+  const randomFactor = randomize ? Math.random() + 1 : 1;
+  const delay = Math.round(
+    randomFactor * Math.max(min, 1) * Math.pow(factor, attempt)
+  );
+  return Math.min(delay, max);
+};
+var AbortRetry = class extends Error {
+  name = "AbortRetry";
+  _error;
+  constructor(error) {
+    super();
+    this._error = error;
+  }
+};
+function range(start, end) {
+  return [...Array(end - start + 1).keys()].map((i) => i + start);
+}
+
+// src/util/fetchWithTimeout.ts
+async function fetchWithTimeout(input, init = {}, timeout = 6e4) {
+  try {
+    return await fetch(input, {
+      ...init,
+      signal: AbortSignal.timeout(timeout)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new TimeoutError(`Request timed out after ${timeout} ms`);
+    }
+    throw error;
+  }
+}
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+};
+
+// src/OaiPmhClient.ts
+var parseDatestamp = (datestamp) => {
+  if (!datestamp)
+    return void 0;
+  if (datestamp.match(/^\d{4}-\d{2}-\d{2}$/)) {
+    return /* @__PURE__ */ new Date(`${datestamp}T00:00:00Z`);
+  }
+  if (datestamp.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/)) {
+    return new Date(datestamp);
+  }
+  throw new Error(`Unknown datestamp format: ${datestamp}`);
+};
+var parseErrorResponse = (doc) => {
+  const errorElement = doc.elements("/oai:OAI-PMH/oai:error")[0];
+  return errorElement ? new OaiPmhError({
+    // Ref: http://www.openarchives.org/OAI/openarchivesprotocol.html#ErrorConditions
+    code: errorElement.attr("code") ?? "noErrorCode",
+    description: errorElement.text()
+  }) : void 0;
+};
+var parseOaiPmhRecord = (record) => ({
+  header: OaiPmhHeader.parse({
+    identifier: record.text("oai:header/oai:identifier"),
+    deleted: record.elements("oai:header")[0]?.attr("status") === "deleted",
+    datestamp: parseDatestamp(record.text("oai:header/oai:datestamp")),
+    setSpec: record.elements("oai:header/oai:setSpec").map((node) => node.text())
+  }),
+  metadata: record.elements("oai:metadata/*")[0]
+});
+var parseListRecordsResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const resumptionToken = doc.text(
+    "/oai:OAI-PMH/oai:ListRecords/oai:resumptionToken"
+  );
+  const records = doc.elements("/oai:OAI-PMH/oai:ListRecords/oai:record").map(parseOaiPmhRecord);
+  return { error, resumptionToken, records };
+};
+var parseListSetsResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const sets = doc.elements("/oai:OAI-PMH/oai:ListSets/oai:set").map(
+    (element) => OaiPmhSet.parse({
+      setSpec: element.text("oai:setSpec"),
+      setName: element.text("oai:setName")
+    })
+  );
+  return { error, sets };
+};
+var parseGetRecordResponse = (doc) => {
+  const error = parseErrorResponse(doc);
+  const records = doc.elements("/oai:OAI-PMH/oai:GetRecord/oai:record").map(parseOaiPmhRecord);
+  return { error, records };
+};
+var OaiPmhClient = class {
+  url;
+  metadataPrefix;
+  set;
+  log;
+  headers;
+  retryOptions;
+  retryOnOaiPmhError;
+  timeoutMs;
+  constructor(config) {
+    this.url = config.url;
+    this.log = config.log ?? dummyLogger;
+    this.metadataPrefix = config.metadataPrefix;
+    this.set = config.set;
+    this.headers = config.headers ?? {};
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+    this.retryOptions = {
+      attempts: config.retry?.attempts ?? 10,
+      delay: config.retry?.delay ?? exponentialBackoff({ min: 2e3, max: 3e4 }),
+      onRetry: config.retry?.onRetry ?? void 0
+    };
+    this.retryOnOaiPmhError = config.retryOnOaiPmhError ?? false;
+  }
+  async request(params) {
+    const searchParams = new URLSearchParams(shake({ ...params }));
+    const url = `${this.url}?${searchParams.toString()}`;
+    this.log.debug(`OAI-PMH request: ${url}`);
+    const response = await fetchWithTimeout(
+      url,
+      {
+        headers: {
+          "User-Agent": "bs-metadata-oai-harvester/0.1.0 (Biblioteksentralen; drift@bibsent.no)",
+          ...this.headers
+        }
+      },
+      this.timeoutMs
+    );
+    if (response.status === 404) {
+      throw new AbortRetry(
+        new HttpError(
+          response,
+          `OAI-PMH endpoint does not exist (got ${response.status} response)`
+        )
+      );
+    }
+    if (!response.ok) {
+      const responseText = await response.text();
+      throw new HttpError(
+        response,
+        `Request failed with ${response.status} response: ${responseText}`
+      );
+    }
+    return response;
+  }
+  parseXmlResponse(response) {
+    return parseXml(response, {
+      log: this.log,
+      namespaces: {
+        oai: "http://www.openarchives.org/OAI/2.0/"
+      }
+    });
+  }
+  async *listRecordBatches({
+    resumptionToken,
+    ...params
+  } = {}) {
+    do {
+      const result = await retry(async () => {
+        const response = await this.request(
+          resumptionToken ? { verb: "ListRecords", resumptionToken } : {
+            verb: "ListRecords",
+            metadataPrefix: this.metadataPrefix,
+            set: this.set,
+            ...params
+          }
+        );
+        const responseText = await response.text();
+        const responseXml = this.parseXmlResponse(responseText);
+        const listResponse = parseListRecordsResponse(responseXml);
+        if (listResponse.error && this.retryOnOaiPmhError) {
+          throw new OaiPmhError(listResponse.error);
+        }
+        return listResponse;
+      }, this.retryOptions);
+      if (result.error) {
+        throw new OaiPmhError(result.error);
+      }
+      yield result;
+      resumptionToken = result.resumptionToken;
+    } while (resumptionToken);
+  }
+  async *listRecords(params = {}) {
+    for await (const response of this.listRecordBatches(params)) {
+      const { records, resumptionToken } = response;
+      for (const record of records) {
+        yield { record, resumptionToken };
+      }
+    }
+  }
+  async getRecord(recordId) {
+    const response = await this.request({
+      verb: "GetRecord",
+      metadataPrefix: this.metadataPrefix,
+      identifier: recordId
+    });
+    const responseText = await response.text();
+    const responseXml = this.parseXmlResponse(responseText);
+    const { records, error } = parseGetRecordResponse(responseXml);
+    return { record: records[0], error };
+  }
+  async listSets() {
+    const response = await this.request({ verb: "ListSets" });
+    const responseText = await response.text();
+    const responseXml = this.parseXmlResponse(responseText);
+    return parseListSetsResponse(responseXml);
+  }
+};
+
+export { HttpError, OaiPmhClient, OaiPmhError, OaiPmhHeader, OaiPmhSet, exponentialBackoff, parseListRecordsResponse, parseListSetsResponse };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@biblioteksentralen/oai-pmh-client",
+  "version": "0.0.1",
+  "private": false,
+  "description": "OAI-PMH client",
+  "author": "Biblioteksentralen",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "dist/**/*.{js,mjs,d.ts}"
+  ],
+  "devDependencies": {
+    "@types/node": "^18.19.31",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "@dataplattform/eslint-config": "1.0.0"
+  },
+  "dependencies": {
+    "pino": "^8.20.0",
+    "radash": "^12.1.0",
+    "ts-log": "^2.2.5",
+    "xpath": "^0.0.32",
+    "zod": "^3.22.4",
+    "@biblioteksentralen/marc": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --treeshake",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "clean": "rimraf dist",
+    "lint": "eslint ."
+  }
+}