aspernaturalias 1.0.0

package/packages/arcgis-rest-auth/src/authenticated-request-options.ts

@@ -0,0 +1,24 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ApplicationSession } from "./ApplicationSession";
+import { UserSession } from "./UserSession";
+
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+
+/**
+ * Used internally by packages for requests that require user authentication.
+ */
+export interface IAuthenticatedRequestOptions extends IRequestOptions {
+  authentication: UserSession | ApplicationSession;
+}
+
+/**
+ * Used internally by packages for requests that require authentication.
+ */
+export interface IUserRequestOptions extends IRequestOptions {
+  /**
+   * A session representing a logged in user.
+   */
+  authentication: UserSession;
+}

package/packages/arcgis-rest-auth/src/fetch-token.ts

@@ -0,0 +1,50 @@
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  request,
+  IRequestOptions,
+  ITokenRequestOptions
+} from "@esri/arcgis-rest-request";
+
+interface IFetchTokenRawResponse {
+  access_token: string;
+  expires_in: number;
+  username: string;
+  ssl?: boolean;
+  refresh_token?: string;
+}
+
+export interface IFetchTokenResponse {
+  token: string;
+  expires: Date;
+  username: string;
+  ssl: boolean;
+  refreshToken?: string;
+}
+
+export function fetchToken(
+  url: string,
+  requestOptions: ITokenRequestOptions
+): Promise<IFetchTokenResponse> {
+  const options: IRequestOptions = requestOptions;
+  // we generate a response, so we can't return the raw response
+  options.rawResponse = false;
+
+  return request(url, options).then((response: IFetchTokenRawResponse) => {
+    const r: IFetchTokenResponse = {
+      token: response.access_token,
+      username: response.username,
+      expires: new Date(
+        // convert seconds in response to milliseconds and add the value to the current time to calculate a static expiration timestamp
+        Date.now() + (response.expires_in * 1000 - 1000)
+      ),
+      ssl: response.ssl === true
+    };
+    if (response.refresh_token) {
+      r.refreshToken = response.refresh_token;
+    }
+
+    return r;
+  });
+}

package/packages/arcgis-rest-auth/src/generate-token.ts

@@ -0,0 +1,35 @@
+/* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  request,
+  IRequestOptions,
+  ITokenRequestOptions,
+  NODEJS_DEFAULT_REFERER_HEADER
+} from "@esri/arcgis-rest-request";
+
+export interface IGenerateTokenResponse {
+  token: string;
+  expires: number;
+  ssl: boolean;
+}
+
+export function generateToken(
+  url: string,
+  requestOptions: ITokenRequestOptions
+): Promise<IGenerateTokenResponse> {
+  const options: IRequestOptions = requestOptions;
+
+  /* istanbul ignore else */
+  if (
+    typeof window !== "undefined" &&
+    window.location &&
+    window.location.host
+  ) {
+    options.params.referer = window.location.host;
+  } else {
+    options.params.referer = NODEJS_DEFAULT_REFERER_HEADER;
+  }
+
+  return request(url, options);
+}

package/packages/arcgis-rest-auth/src/index.ts

@@ -0,0 +1,9 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export * from "./ApplicationSession";
+export * from "./UserSession";
+export * from "./fetch-token";
+export * from "./generate-token";
+export * from "./authenticated-request-options";
+export { IUser } from "@esri/arcgis-rest-types";

package/packages/arcgis-rest-auth/test/ApplicationSession.test.ts

@@ -0,0 +1,124 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ApplicationSession } from "../src/index";
+import * as fetchMock from "fetch-mock";
+import { YESTERDAY, TOMORROW } from "./utils";
+
+describe("ApplicationSession", () => {
+  afterEach(fetchMock.restore);
+
+  describe(".getToken()", () => {
+    it("should return the cached token if it is not expired", done => {
+      const session = new ApplicationSession({
+        clientId: "id",
+        clientSecret: "secret",
+        token: "token",
+        expires: TOMORROW
+      });
+
+      Promise.all([
+        session.getToken("https://www.arcgis.com/sharing/rest/portals/self"),
+        session.getToken(
+          "https://services1.arcgis.com/MOCK_ORG/arcgis/rest/services/Private_Service/FeatureServer"
+        )
+      ])
+        .then(([token1, token2]) => {
+          expect(token1).toBe("token");
+          expect(token2).toBe("token");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should fetch a new token if the cached one is expired", done => {
+      const session = new ApplicationSession({
+        clientId: "id",
+        clientSecret: "secret",
+        token: "token",
+        expires: YESTERDAY
+      });
+
+      fetchMock.post("https://www.arcgis.com/sharing/rest/oauth2/token/", {
+        access_token: "new",
+        expires_in: 1800
+      });
+
+      Promise.all([
+        session.getToken("https://www.arcgis.com/sharing/rest/portals/self"),
+        session.getToken(
+          "https://services1.arcgis.com/MOCK_ORG/arcgis/rest/services/Private_Service/FeatureServer"
+        )
+      ])
+        .then(([token1, token2]) => {
+          expect(token1).toBe("new");
+          expect(token2).toBe("new");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should not make multiple refresh requests while a refresh is pending", done => {
+      const session = new ApplicationSession({
+        clientId: "id",
+        clientSecret: "secret",
+        token: "token",
+        expires: YESTERDAY
+      });
+
+      fetchMock.mock(
+        "https://www.arcgis.com/sharing/rest/oauth2/token/",
+        {
+          access_token: "new",
+          expires_in: 1800
+        },
+        { method: "POST", repeat: 1 }
+      );
+
+      Promise.all([
+        session.getToken("https://www.arcgis.com/sharing/rest/portals/self"),
+        session.getToken("https://www.arcgis.com/sharing/rest/portals/self")
+      ])
+        .then(([token1, token2]) => {
+          expect(token1).toBe("new");
+          expect(token2).toBe("new");
+          expect(
+            fetchMock.calls("https://www.arcgis.com/sharing/rest/oauth2/token/")
+              .length
+          ).toBe(1);
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  it("should provide a method to refresh a session", done => {
+    const session = new ApplicationSession({
+      clientId: "id",
+      clientSecret: "secret",
+      token: "token",
+      expires: YESTERDAY
+    });
+
+    fetchMock.post("https://www.arcgis.com/sharing/rest/oauth2/token/", {
+      access_token: "new",
+      expires_in: 1800
+    });
+
+    session
+      .refreshSession()
+      .then(s => {
+        expect(s).toBe(session);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});