aspernaturalias 1.0.0

package/packages/arcgis-rest-service-admin/src/addTo.ts

@@ -0,0 +1,70 @@
+/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, cleanUrl } from "@esri/arcgis-rest-request";
+import { ILayer, ILayerDefinition, ITable } from "@esri/arcgis-rest-types";
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+
+export interface IAddToServiceDefinitionOptions extends IUserRequestOptions {
+  /**
+   * Layers to add
+   */
+  layers?: ILayer[] | ILayerDefinition[];
+  /**
+   * Tables to add
+   */
+  tables?: ITable[];
+}
+
+export interface IAddToServiceDefinitionItemSummary {
+  name: string;
+  id: any;
+}
+
+export interface IAddToServiceDefinitionResult {
+  layers?: IAddToServiceDefinitionItemSummary[];
+  tables?: IAddToServiceDefinitionItemSummary[];
+  success: boolean;
+}
+
+/**
+ * ```js
+ * import { addToServiceDefinition } from '@esri/arcgis-rest-service-admin';
+ * //
+ * addToServiceDefinition(serviceurl, {
+ *   authentication: userSession,
+ *   layers: [],
+ *   tables: []
+ * });
+ * ```
+ * Add layer(s) and/or table(s) to a hosted feature service. See the [REST Documentation](https://developers.arcgis.com/rest/services-reference/add-to-definition-feature-service-.htm) for more information.
+ *
+ * @param url - URL of feature service
+ * @param requestOptions - Options for the request
+ * @returns A Promise that resolves with service layer and/or table details once the definition
+ * has been updated
+ */
+export function addToServiceDefinition(
+  url: string,
+  requestOptions: IAddToServiceDefinitionOptions
+): Promise<IAddToServiceDefinitionResult> {
+  const adminUrl = `${cleanUrl(url).replace(
+    `/rest/services`,
+    `/rest/admin/services`
+  )}/addToDefinition`;
+
+  requestOptions.params = {
+    addToDefinition: {},
+    ...requestOptions.params
+  };
+
+  if (requestOptions.layers && requestOptions.layers.length > 0) {
+    requestOptions.params.addToDefinition.layers = requestOptions.layers;
+  }
+
+  if (requestOptions.tables && requestOptions.tables.length > 0) {
+    requestOptions.params.addToDefinition.tables = requestOptions.tables;
+  }
+
+  return request(adminUrl, requestOptions);
+}

package/packages/arcgis-rest-service-admin/src/create.ts

@@ -0,0 +1,213 @@
+/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request } from "@esri/arcgis-rest-request";
+import { IExtent, ISpatialReference } from "@esri/arcgis-rest-types";
+
+import {
+  moveItem,
+  ICreateUpdateItemOptions,
+  determineOwner,
+  getPortalUrl
+} from "@esri/arcgis-rest-portal";
+
+/**
+ * A [`createParameters` JSON object for a new
+ * service](https://developers.arcgis.com/rest/users-groups-and-items/create-service.htm).
+ */
+export interface ICreateServiceParams {
+  /**
+   * Name of the service to be created. This name must be unique. If the name already exists, the operation will fail. ArcGIS Enterprise does not allow spaces or special characters other than underscores in a service name.
+   */
+  name: string;
+  /**
+   * Description given to the service.
+   */
+  serviceDescription?: string;
+  /**
+   * Indicates whether the data changes.
+   */
+  hasStaticData?: boolean;
+  /**
+   * A double value indicating any constraints enforced on query operations.
+   */
+  maxRecordCount?: number;
+  /**
+   * The formats in which query results are returned.
+   */
+  supportedQueryFormats?: string;
+  /**
+   * Specify feature service editing capabilities for Create, Delete, Query, Update, and Sync.
+   */
+  capabilities?: string;
+  /**
+   * A user-friendly description for the published dataset.
+   */
+  description?: string;
+  /**
+   * Copyright information associated with the dataset.
+   */
+  copyrightText?: string;
+  /**
+   * All layers added to a hosted feature service need to have the same spatial reference defined for
+   * the feature service. When creating a new empty service without specifying its spatial reference,
+   * the spatial reference of the hosted feature service is set to the first layer added to that
+   * feature service.
+   */
+  spatialReference?: ISpatialReference;
+  /**
+   * The initial extent set for the service.
+   */
+  initialExtent?: IExtent;
+  /**
+   * Indicates if updating the geometry of the service is permitted.
+   */
+  allowGeometryUpdates?: boolean;
+  /**
+   * Units used by the feature service
+   */
+  units?: string;
+  /**
+   * A JSON object specifying the properties of cross-site scripting prevention.
+   */
+  xssPreventionInfo?: any;
+  /**
+   * Editor tracking info.
+   */
+  editorTrackingInfo?: {
+    enableEditorTracking?: boolean;
+    enableOwnershipAccessControl?: boolean;
+    allowOthersToUpdate?: boolean;
+    allowOthersToDelete?: boolean;
+    allowOthersToQuery?: boolean;
+    allowAnonymousToUpdate?: boolean;
+    allowAnonymousToDelete?: boolean;
+  };
+}
+
+export interface ICreateServiceOptions extends ICreateUpdateItemOptions {
+  /**
+   * A JSON object specifying the properties of the newly-created service. See the [REST
+   * Documentation](https://developers.arcgis.com/rest/users-groups-and-items/working-with-users-groups-and-items.htm)
+   * for more information.
+   */
+  item: ICreateServiceParams;
+  /**
+   * Alphanumeric id of folder to house moved item. If null, empty, or "/", the destination is the
+   * root folder.
+   */
+  folderId?: string;
+}
+
+export interface ICreateServiceResult {
+  /**
+   * The encoded URL to the hosted service.
+   */
+  encodedServiceURL: string;
+
+  /**
+   * Indicates if this feature service represents a view.
+   */
+  isView: boolean;
+
+  /**
+   * The unique ID for this item.
+   */
+  itemId: string;
+
+  /**
+   * Name of the service item.
+   */
+  name: string;
+
+  /**
+   * The ID of the new service item.
+   */
+  serviceItemId: string;
+
+  /**
+   * The URL to the hosted service.
+   */
+  serviceurl: string;
+
+  /**
+   * The size of the item.
+   */
+  size: number;
+
+  /**
+   * Indicates if the operation was successful.
+   */
+  success: boolean;
+
+  /**
+   * The type of service created.
+   */
+  type: string;
+}
+
+/**
+ * ```js
+ * import {
+ *   createFeatureService,
+ *   addToServiceDefinition
+ * } from '@esri/arcgis-rest-service-admin';
+ * //
+ * createFeatureService({
+ *   authentication: userSession,
+ *   item: {
+ *     "name": "NewEmptyService",
+ *     "capabilities": "Create,Delete,Query,Update,Editing"
+ *   }
+ * });
+ * ```
+ * Create a new [hosted feature service](https://developers.arcgis.com/rest/users-groups-and-items/create-service.htm). After the service has been created, call [`addToServiceDefinition()`](../addToServiceDefinition/) if you'd like to update it's schema.
+ * @param requestOptions - Options for the request. NOTE: `rawResponse` is not supported by this operation.
+ * @returns A Promise that resolves with service details once the service has been created
+ */
+export function createFeatureService(
+  requestOptions: ICreateServiceOptions
+): Promise<ICreateServiceResult> {
+  const owner = determineOwner(requestOptions);
+  const baseUrl = `${getPortalUrl(requestOptions)}/content/users/${owner}`;
+  const url = `${baseUrl}/createService`;
+  const options: ICreateServiceOptions = {
+    ...requestOptions,
+    rawResponse: false
+  };
+
+  // Create the service
+  options.params = {
+    createParameters: options.item,
+    outputType: "featureService",
+    ...options.params
+  };
+
+  if (!options.folderId || options.folderId === "/") {
+    // If the service is destined for the root folder, just send the request
+    return request(url, options);
+  } else {
+    // If the service is destined for a subfolder, move it (via another call)
+    return request(url, options).then(createResponse => {
+      if (createResponse.success) {
+        return moveItem({
+          itemId: createResponse.itemId,
+          folderId: options.folderId,
+          authentication: options.authentication
+        }).then(moveResponse => {
+          if (moveResponse.success) {
+            return createResponse;
+          } else {
+            throw Error(
+              `A problem was encountered when trying to move the service to a different folder.`
+            );
+          }
+        });
+      } else {
+        throw Error(
+          `A problem was encountered when trying to create the service.`
+        );
+      }
+    });
+  }
+}

package/packages/arcgis-rest-service-admin/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./create";
+export * from "./addTo";
+export {
+  IExtent,
+  ISpatialReference,
+  ILayer,
+  ILayerDefinition,
+  ITable
+} from "@esri/arcgis-rest-types";

package/packages/arcgis-rest-service-admin/test/addTo.test.ts

@@ -0,0 +1,350 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+import { encodeParam, ErrorTypes } from "@esri/arcgis-rest-request";
+import { ILayer, ITable } from "@esri/arcgis-rest-types";
+import { addToServiceDefinition } from "../src/addTo";
+import {
+  AddToFeatureServiceSuccessResponseFredAndGinger,
+  AddToFeatureServiceSuccessResponseFayardAndHarold,
+  AddToFeatureServiceSuccessResponseCydAndGene,
+  AddToFeatureServiceError
+} from "./mocks/service";
+import { layerDefinitionSid } from "./mocks/layerDefinition";
+
+describe("add to feature service", () => {
+  afterEach(fetchMock.restore);
+
+  describe("Authenticated methods", () => {
+    // setup a UserSession to use in all these tests
+    const MOCK_USER_SESSION = new UserSession({
+      clientId: "clientId",
+      redirectUri: "https://example-app.com/redirect-uri",
+      token: "fake-token",
+      tokenExpires: TOMORROW,
+      refreshToken: "refreshToken",
+      refreshTokenExpires: TOMORROW,
+      refreshTokenTTL: 1440,
+      username: "casey",
+      password: "123456",
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    });
+
+    const MOCK_USER_REQOPTS = {
+      authentication: MOCK_USER_SESSION
+    };
+
+    const layerDescriptionFred: ILayer = {
+      name: "Fred",
+      id: "1899",
+      layerType: "Feature Layer"
+    };
+
+    const layerDescriptionGinger: ILayer = {
+      name: "Ginger",
+      id: "1911",
+      layerType: "Feature Layer"
+    };
+
+    const layerDescriptionCyd: ILayer = {
+      name: "Cyd",
+      id: "1922",
+      layerType: "Feature Layer"
+    };
+
+    const layerDescriptionFail: ILayer = {
+      name: "",
+      id: "",
+      layerType: "Feature Layer"
+    };
+
+    const tableDescriptionFayard: ITable = {
+      name: "Fayard",
+      id: "1914"
+    };
+
+    const tableDescriptionHarold: ITable = {
+      name: "Harold",
+      id: "1921"
+    };
+
+    const tableDescriptionGene: ITable = {
+      name: "Gene",
+      id: "1912"
+    };
+
+    const tableDescriptionFail: ITable = {
+      name: "",
+      id: ""
+    };
+
+    it("should add a pair of layers", done => {
+      fetchMock.once("*", AddToFeatureServiceSuccessResponseFredAndGinger);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          layers: [layerDescriptionFred, layerDescriptionGinger],
+          ...MOCK_USER_REQOPTS
+        }
+      )
+        .then(
+          response => {
+            // Check service call
+            expect(fetchMock.called()).toEqual(true);
+            const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+              "*"
+            );
+
+            expect(url).toEqual(
+              "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+            );
+            expect(options.method).toBe("POST");
+            expect(options.body).toContain("f=json");
+            expect(options.body).toContain(encodeParam("token", "fake-token"));
+            expect(options.body).toContain(
+              encodeParam(
+                "addToDefinition",
+                JSON.stringify({
+                  layers: [layerDescriptionFred, layerDescriptionGinger]
+                })
+              )
+            );
+
+            // Check response
+            expect(response).toEqual(
+              AddToFeatureServiceSuccessResponseFredAndGinger
+            );
+
+            done();
+          },
+          () => {
+            fail(); // call is supposed to succeed
+          }
+        )
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should add a pair of tables", done => {
+      fetchMock.once("*", AddToFeatureServiceSuccessResponseFayardAndHarold);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          tables: [tableDescriptionFayard, tableDescriptionHarold],
+          ...MOCK_USER_REQOPTS
+        }
+      )
+        .then(
+          response => {
+            // Check service call
+            expect(fetchMock.called()).toEqual(true);
+            const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+              "*"
+            );
+
+            expect(url).toEqual(
+              "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+            );
+            expect(options.method).toBe("POST");
+            expect(options.body).toContain("f=json");
+            expect(options.body).toContain(encodeParam("token", "fake-token"));
+            expect(options.body).toContain(
+              encodeParam(
+                "addToDefinition",
+                JSON.stringify({
+                  tables: [tableDescriptionFayard, tableDescriptionHarold]
+                })
+              )
+            );
+
+            // Check response
+            expect(response).toEqual(
+              AddToFeatureServiceSuccessResponseFayardAndHarold
+            );
+
+            done();
+          },
+          () => {
+            fail(); // call is supposed to succeed
+          }
+        )
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should add a layer and a table", done => {
+      fetchMock.once("*", AddToFeatureServiceSuccessResponseCydAndGene);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          layers: [layerDescriptionCyd],
+          tables: [tableDescriptionGene],
+          ...MOCK_USER_REQOPTS
+        }
+      )
+        .then(response => {
+          // Check service call
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+
+          expect(url).toEqual(
+            "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(
+            encodeParam(
+              "addToDefinition",
+              JSON.stringify({
+                layers: [layerDescriptionCyd],
+                tables: [tableDescriptionGene]
+              })
+            )
+          );
+
+          // Check response
+          expect(response).toEqual(
+            AddToFeatureServiceSuccessResponseCydAndGene
+          );
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should add a layer definition", done => {
+      fetchMock.once("*", AddToFeatureServiceSuccessResponseCydAndGene);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          layers: [layerDefinitionSid],
+          ...MOCK_USER_REQOPTS
+        }
+      )
+        .then(response => {
+          // Check service call
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+
+          expect(url).toEqual(
+            "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(
+            encodeParam(
+              "addToDefinition",
+              JSON.stringify({
+                layers: [layerDefinitionSid]
+              })
+            )
+          );
+
+          // Check response
+          expect(response).toEqual(
+            AddToFeatureServiceSuccessResponseCydAndGene
+          );
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should fail to add a bad layer", done => {
+      fetchMock.once("*", AddToFeatureServiceError);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          layers: [layerDescriptionFail],
+          ...MOCK_USER_REQOPTS
+        }
+      ).catch(error => {
+        expect(error.name).toBe(ErrorTypes.ArcGISRequestError);
+        expect(error.message).toBe(
+          "400: Unable to add feature service definition."
+        );
+        expect(error instanceof Error).toBeTruthy();
+        expect(error.url).toBe(
+          "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+        );
+        // params added internally aren't surfaced in the error
+        expect(error.options.params.addToDefinition).toEqual({
+          layers: [layerDescriptionFail]
+        });
+        expect(error.options.httpMethod).toEqual("POST");
+        done();
+      });
+    });
+
+    it("should fail to add a bad table", done => {
+      fetchMock.once("*", AddToFeatureServiceError);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          tables: [tableDescriptionFail],
+          ...MOCK_USER_REQOPTS
+        }
+      ).catch(error => {
+        expect(error.name).toBe(ErrorTypes.ArcGISRequestError);
+        expect(error.message).toBe(
+          "400: Unable to add feature service definition."
+        );
+        expect(error instanceof Error).toBeTruthy();
+        expect(error.url).toBe(
+          "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+        );
+        // params added internally aren't surfaced in the error
+        expect(error.options.params.addToDefinition).toEqual({
+          tables: [tableDescriptionFail]
+        });
+        expect(error.options.httpMethod).toEqual("POST");
+        done();
+      });
+    });
+
+    it("should fail to add a bad layer and a bad table", done => {
+      fetchMock.once("*", AddToFeatureServiceError);
+
+      addToServiceDefinition(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer",
+        {
+          layers: [layerDescriptionFail],
+          tables: [tableDescriptionFail],
+          ...MOCK_USER_REQOPTS
+        }
+      ).catch(error => {
+        expect(error.name).toBe(ErrorTypes.ArcGISRequestError);
+        expect(error.message).toBe(
+          "400: Unable to add feature service definition."
+        );
+        expect(error instanceof Error).toBeTruthy();
+        expect(error.url).toBe(
+          "https://services1.arcgis.com/ORG/arcgis/rest/admin/services/FEATURE_SERVICE/FeatureServer/addToDefinition"
+        );
+        // params added internally aren't surfaced in the error
+        expect(error.options.params.addToDefinition).toEqual({
+          tables: [tableDescriptionFail],
+          layers: [layerDescriptionFail]
+        });
+        expect(error.options.httpMethod).toEqual("POST");
+        done();
+      });
+    });
+  }); // auth requests
+});