@globus/sdk 0.7.3 → 1.0.0-alpha

package/src/lib/core/url.ts

@@ -0,0 +1,73 @@
+import { getServiceBaseUrl, getEnvironment, Environment } from "./global";
+import type { Service } from "./global";
+import type { GCSConfiguration } from "../services/globus-connect-server";
+
+/**
+ * Return the base URL for a service (based on the environment).
+ * @param service The service to build the URL for.
+ * @param path The path to the resource.
+ * @param environment The environment to use.
+ */
+export function getServiceURL(
+  service: Service,
+  path = "",
+  environment: Environment = getEnvironment()
+): URL {
+  const base = getServiceBaseUrl(service, environment);
+  return new URL(path, base);
+}
+
+/**
+ * Build a URL for a service or GCSConfiguration.
+ *
+ * @param service The service identifier or GCSConfiguration object to build the URL for.
+ * @param path The path to the resource.
+ * @param options Additional options for the URL.
+ */
+export function build(
+  serviceOrConfiguration: Service | GCSConfiguration,
+  path: string,
+  options?: {
+    search?: Parameters<typeof stringifyParameters>[0];
+  }
+) {
+  let url;
+  if (typeof serviceOrConfiguration === "object") {
+    url = new URL(path, serviceOrConfiguration.host);
+  } else {
+    url = getServiceURL(serviceOrConfiguration, path);
+  }
+  if (options && options.search) {
+    url.search = stringifyParameters(options.search);
+  }
+  return url.toString();
+}
+
+/**
+ * An extremely simplified parameter serializer based on our current needs.
+ *
+ * **This is intended for internal @globus/sdk use only.**
+ *
+ * @private
+ */
+export function stringifyParameters(parameters: {
+  [key: string]:
+    | string
+    | number
+    | Array<string | number | null | undefined>
+    | null
+    | undefined;
+}) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(parameters)) {
+    if (Array.isArray(value)) {
+      /**
+       * Arrays are converted to comma-separated strings.
+       */
+      search.set(key, value.join(","));
+    } else if (value !== undefined) {
+      search.set(key, String(value));
+    }
+  }
+  return search.toString();
+}

package/src/lib/services/auth/config.ts

@@ -0,0 +1,11 @@
+import type { Environment } from "../../core/global";
+
+export const ID = "AUTH";
+export const HOSTS: Partial<Record<Environment, string>> = {
+  integration: "auth.integration.globuscs.info",
+  sandbox: "auth.sandbox.globuscs.info",
+  production: "auth.globus.org",
+  test: "auth.test.globuscs.info",
+  staging: "auth.staging.globuscs.info",
+  preview: "auth.preview.globus.org",
+};

package/src/lib/services/auth/index.ts

@@ -0,0 +1,37 @@
+/**
+ * @description A wrapper around the Globus Auth service.
+ * @group Service
+ * @see [Globus Auth API Documentation](https://docs.globus.org/api/auth/)
+ * @module
+ */
+import { build } from "../../core/url";
+
+import * as AUTH from "./config";
+
+/**
+ * @private
+ * @internal
+ */
+export const CONFIG = AUTH;
+
+import type ITokenResponse from "js-pkce/dist/ITokenResponse";
+
+export function getAuthorizationEndpoint() {
+  return build(AUTH.ID, "/v2/oauth2/authorize");
+}
+
+export function getTokenEndpoint() {
+  return build(AUTH.ID, "/v2/oauth2/token");
+}
+
+export type Token = ITokenResponse & {
+  resource_server: string;
+  id_token?: string;
+};
+/**
+ * @see https://docs.globus.org/api/auth/reference/#authorization_code_grant_preferred
+ */
+export type TokenResponse = Token & {
+  state: string;
+  other_tokens: Token[];
+};

package/src/lib/services/auth/types.ts

@@ -0,0 +1,15 @@
+import ITokenResponse from "js-pkce/dist/ITokenResponse";
+
+export namespace Globus.Auth {
+  export type Token = ITokenResponse & {
+    resource_server: string;
+    id_token?: string;
+  };
+  /**
+   * @see https://docs.globus.org/api/auth/reference/#authorization_code_grant_preferred
+   */
+  export type TokenResponse = Token & {
+    state: string;
+    other_tokens: Token[];
+  };
+}

package/src/lib/services/flows/__tests__/flows.spec.ts

@@ -0,0 +1,12 @@
+import serviceTestSuite from "../../../../__utils__/service-test-suite";
+import { flows } from "..";
+
+serviceTestSuite("flows", "flows", (fetch) => {
+  test("getAll", async () => {
+    await flows.getAll();
+    expect(fetch).toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalledWith(`https://flows.globus.org/flows`, {
+      headers: {},
+    });
+  });
+});

package/src/lib/services/flows/__tests__/runs.spec.ts

@@ -0,0 +1,12 @@
+import serviceTestSuite from "../../../../__utils__/service-test-suite";
+import { runs } from "..";
+
+serviceTestSuite("flows", "runs", (fetch) => {
+  test("getAll", async () => {
+    await runs.getAll();
+    expect(fetch).toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalledWith(`https://flows.globus.org/runs`, {
+      headers: {},
+    });
+  });
+});

package/src/lib/services/flows/config.ts

@@ -0,0 +1,26 @@
+import type { Environment } from "../../core/global";
+
+export const ID = "FLOWS";
+export const HOSTS: Partial<Record<Environment, string>> = {
+  sandbox: "sandbox.flows.automate.globus.org",
+  production: "flows.globus.org",
+  staging: "staging.flows.automate.globus.org",
+  integration: "integration.flows.automate.globus.org",
+  test: "test.flows.automate.globus.org",
+  preview: "preview.flows.automate.globus.org",
+};
+
+/**
+ * @see https://docs.globus.org/api/flows/overview/#scopes
+ */
+export const SCOPES = {
+  MANAGE_FLOWS:
+    "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/manage_flows",
+  VIEW_FLOWS:
+    "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/view_flows",
+  RUN: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run",
+  RUN_STATUS:
+    "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run_status",
+  RUN_MANAGE:
+    "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run_manage",
+};

package/{dist/commonjs/src/lib/services/flows/index.d.ts → src/lib/services/flows/index.ts}

@@ -5,11 +5,12 @@
  * @module
  */
 import * as FLOWS from "./config";
+
 /**
  * @private
  * @internal
  */
-export declare const CONFIG: typeof FLOWS;
+export const CONFIG = FLOWS;
+
 export * as flows from "./service/flows";
 export * as runs from "./service/runs";
-//# sourceMappingURL=index.d.ts.map

package/src/lib/services/flows/service/flows.ts

@@ -0,0 +1,41 @@
+import { build } from "../../../core/url";
+import { fetchWithScope } from "../../../core/fetch";
+
+import type {
+  ServiceMethod,
+  ServiceMethodDynamicSegments,
+} from "../../../services/types";
+
+import { ID, SCOPES } from "../config";
+
+/**
+ * @see https://globusonline.github.io/flows/#tag/Flows/paths/~1flows/get
+ */
+export const getAll = function (parameters = {}, options?) {
+  return fetchWithScope(
+    SCOPES.VIEW_FLOWS,
+    build(ID, `/flows`, {
+      search: parameters,
+    }),
+    options?.fetch?.options
+  );
+} satisfies ServiceMethod<Record<string, string>>;
+
+/**
+ * @see https://globusonline.github.io/flows/#tag/Flows/paths/~1flows~1{flow_id}/get
+ */
+export const get = function (flow_id, _parameters, sdkOptions?) {
+  return fetchWithScope(SCOPES.VIEW_FLOWS, build(ID, `/flows/${flow_id}`), {
+    ...sdkOptions?.fetch?.options,
+  });
+} satisfies ServiceMethodDynamicSegments<string, never>;
+
+/**
+ * @see https://globusonline.github.io/flows/#tag/Flows/paths/~1flows~1{flow_id}/delete
+ */
+export const destroy = function (flow_id, _parameters?, sdkOptions?) {
+  return fetchWithScope(SCOPES.MANAGE_FLOWS, build(ID, `/flows/${flow_id}`), {
+    ...sdkOptions?.fetch?.options,
+    method: "DELETE",
+  });
+} satisfies ServiceMethodDynamicSegments<string, never>;

package/src/lib/services/flows/service/runs.ts

@@ -0,0 +1,20 @@
+import { build } from "../../../core/url";
+import { fetchWithScope } from "../../../core/fetch";
+
+import type { ServiceMethod } from "../../../services/types";
+
+import { ID, SCOPES } from "../config";
+
+/**
+ *
+ * @see https://globusonline.github.io/flows/#tag/Runs/paths/~1runs/get
+ */
+export const getAll = function (parameters = {}, options?) {
+  return fetchWithScope(
+    SCOPES.RUN_MANAGE,
+    build(ID, `/runs`, {
+      search: parameters,
+    }),
+    options?.fetch?.options
+  );
+} satisfies ServiceMethod<Record<string, string>>;

package/src/lib/services/globus-connect-server/__tests__/client.spec.ts

@@ -0,0 +1,147 @@
+import { createStorage } from "../../../core/storage";
+import { getClient } from "../client";
+
+import type { MirroredRequest } from "../../../../../mocks/handlers";
+
+const GCS_CONFIGURATION = {
+  host: "https://fa5e.bd7c.data.globus.org",
+  endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+};
+
+describe("gcs – client", () => {
+  test("can be created WITHOUT storage", async () => {
+    const client = getClient(GCS_CONFIGURATION);
+
+    const result = await client.endpoint.get(undefined, {
+      fetch: {
+        options: {
+          headers: {
+            Authorization: `Bearer SOME_TOKEN`,
+          },
+        },
+      },
+    });
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "authorization": "Bearer SOME_TOKEN",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/endpoint",
+      }
+    `);
+
+    const result2 = await client.collections.get(
+      "a-b-c-d",
+      {
+        query: {
+          include: ["private_policies"],
+        },
+      },
+      {
+        fetch: {
+          options: {
+            headers: {
+              Authorization: `Bearer SOME_OTHER_TOKEN`,
+            },
+          },
+        },
+      }
+    );
+
+    const {
+      req: { url: url2, method: method2, headers: headers2 },
+    } = (await result2.json()) as unknown as MirroredRequest;
+
+    expect({
+      url: url2,
+      method: method2,
+      headers: headers2,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "authorization": "Bearer SOME_OTHER_TOKEN",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/collections/a-b-c-d?include=private_policies",
+      }
+    `);
+  });
+
+  test("obtain client and call endpoint.get", async () => {
+    createStorage("memory");
+    const client = getClient(GCS_CONFIGURATION);
+    const result = await client.endpoint.get();
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/endpoint",
+      }
+    `);
+  });
+
+  test("obtain client and call collections.get", async () => {
+    createStorage("memory");
+    const client = getClient(GCS_CONFIGURATION);
+    const result = await client.collections.get(
+      "5e70cb38-90b4-4939-b5b7-2f502363004bs",
+      {
+        query: {
+          include: ["private_policies"],
+        },
+      }
+    );
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/collections/5e70cb38-90b4-4939-b5b7-2f502363004bs?include=private_policies",
+      }
+    `);
+  });
+});

package/src/lib/services/globus-connect-server/__tests__/collections.spec.ts

@@ -0,0 +1,73 @@
+import { createStorage } from "../../../core/storage";
+import { collections } from "..";
+
+import type { MirroredRequest } from "../../../../../mocks/handlers";
+
+const GCS_CONFIGURATION = {
+  host: "https://fa5e.bd7c.data.globus.org",
+  endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+};
+
+describe("gcs – collection", () => {
+  createStorage("memory");
+  test("get", async () => {
+    const result = await collections.get(
+      GCS_CONFIGURATION,
+      "5e70cb38-90b4-4939-b5b7-2f502363004bs",
+      {
+        query: {
+          include: ["private_policies"],
+        },
+      }
+    );
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/collections/5e70cb38-90b4-4939-b5b7-2f502363004bs?include=private_policies",
+      }
+    `);
+  });
+
+  test("getAll", async () => {
+    const result = await collections.getAll(GCS_CONFIGURATION, {
+      query: {
+        include: ["private_policies"],
+        mapped_collection_id: "2b6072ed-41d9-4082-83ea-c9ea6e00a107",
+      },
+    });
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/collections?include=private_policies&mapped_collection_id=2b6072ed-41d9-4082-83ea-c9ea6e00a107",
+      }
+    `);
+  });
+});

package/src/lib/services/globus-connect-server/__tests__/endpoint.spec.ts

@@ -0,0 +1,36 @@
+import { createStorage } from "../../../core/storage";
+import { endpoint } from "..";
+
+import type { MirroredRequest } from "../../../../../mocks/handlers";
+
+const GCS_HOST = "https://fa5e.bd7c.data.globus.org";
+
+describe("gcs – endpoint", () => {
+  createStorage("memory");
+  test("get", async () => {
+    const result = await endpoint.get({
+      host: GCS_HOST,
+      endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+    });
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/endpoint",
+      }
+    `);
+  });
+});

package/src/lib/services/globus-connect-server/__tests__/roles.spec.ts

@@ -0,0 +1,151 @@
+import { createStorage } from "../../../core/storage";
+import { roles } from "..";
+
+import type { MirroredRequest } from "../../../../../mocks/handlers";
+
+const GCS_HOST = "https://fa5e.bd7c.data.globus.org";
+
+describe("gcs – roles", () => {
+  createStorage("memory");
+
+  test("getAll", async () => {
+    const result = await roles.getAll(
+      {
+        host: GCS_HOST,
+        endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+      },
+      {
+        query: {
+          include: ["all_roles"],
+        },
+      }
+    );
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/roles?include=all_roles",
+      }
+    `);
+  });
+
+  test("get", async () => {
+    const result = await roles.get(
+      {
+        host: GCS_HOST,
+        endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+      },
+      "some-uuid"
+    );
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "GET",
+        "url": "https://fa5e.bd7c.data.globus.org/api/roles/some-uuid",
+      }
+    `);
+  });
+
+  test("remove", async () => {
+    const result = await roles.remove(
+      {
+        host: GCS_HOST,
+        endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+      },
+      "some-uuid"
+    );
+    const {
+      req: { url, method, headers },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "method": "DELETE",
+        "url": "https://fa5e.bd7c.data.globus.org/api/roles/some-uuid",
+      }
+    `);
+  });
+
+  test("create", async () => {
+    const result = await roles.create(
+      {
+        host: GCS_HOST,
+        endpoint_id: "ac9cb54b-fc48-4824-b801-1388baf0a909",
+      },
+      {
+        payload: {
+          DATA_TYPE: "role#1.0.0",
+          principal:
+            "urn:globus:auth:identity:dd7b1118-8fb0-4d92-9e28-7a3bc9cbfdf7",
+          collection: "476a00e0-0255-4397-91cb-87d054aa494a",
+          role: "activity_manager",
+        },
+      }
+    );
+    const {
+      req: { url, method, headers, json },
+    } = (await result.json()) as unknown as MirroredRequest;
+    expect({
+      url,
+      method,
+      headers,
+      json,
+    }).toMatchInlineSnapshot(`
+      {
+        "headers": {
+          "accept": "*/*",
+          "accept-encoding": "gzip,deflate",
+          "connection": "close",
+          "content-length": "180",
+          "content-type": "application/json",
+          "host": "fa5e.bd7c.data.globus.org",
+          "user-agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)",
+        },
+        "json": {
+          "DATA_TYPE": "role#1.0.0",
+          "collection": "476a00e0-0255-4397-91cb-87d054aa494a",
+          "principal": "urn:globus:auth:identity:dd7b1118-8fb0-4d92-9e28-7a3bc9cbfdf7",
+          "role": "activity_manager",
+        },
+        "method": "POST",
+        "url": "https://fa5e.bd7c.data.globus.org/api/roles",
+      }
+    `);
+  });
+});