ducimusipsa 1.0.0

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

@@ -0,0 +1,207 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, getPortalUrl } from "@esri/arcgis-rest-request";
+import {
+  moveItem,
+  IItemCrudRequestOptions,
+  determineOwner
+} from "@esri/arcgis-rest-items";
+import { IExtent, ISpatialReference } from "@esri/arcgis-rest-common-types";
+
+/**
+ * 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 ICreateServiceRequestOptions extends IItemCrudRequestOptions {
+  /**
+   * 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;
+}
+
+/**
+ * Create a new hosted feature service.
+ *
+ * ```js
+ * import { createFeatureService } from '@esri/arcgis-rest-feature-service-admin';
+ *
+ * createFeatureService({
+ *   authentication: userSession,
+ *   item: {
+ *     "name": "NewEmptyService",
+ *     "capabilities": "Create,Delete,Query,Update,Editing"
+ *   }
+ * });
+ * ```
+ *
+ * @param requestOptions - Options for the request
+ * @returns A Promise that resolves with service details once the service has been created
+ */
+export function createFeatureService(
+  requestOptions: ICreateServiceRequestOptions
+): Promise<ICreateServiceResult> {
+  const owner = determineOwner(requestOptions);
+
+  const baseUrl = `${getPortalUrl(requestOptions)}/content/users/${owner}`;
+  const url = `${baseUrl}/createService`;
+
+  // Create the service
+  requestOptions.params = {
+    createParameters: requestOptions.item,
+    outputType: "featureService",
+    ...requestOptions.params
+  };
+
+  if (!requestOptions.folderId || requestOptions.folderId === "/") {
+    // If the service is destined for the root folder, just send the request and return the promise;
+    // services are created in the root folder
+    return request(url, requestOptions);
+  } else {
+    // If the service is destined for a subfolder, catch the results of the request and then move
+    // the item to the desired folder
+    return new Promise((resolve, reject) => {
+      request(url, requestOptions).then(createResults => {
+        if (createResults.success) {
+          moveItem({
+            itemId: createResults.itemId,
+            folderId: requestOptions.folderId,
+            authentication: requestOptions.authentication
+          }).then(moveResults => {
+            if (moveResults.success) {
+              resolve(createResults);
+            } else {
+              reject({ success: false });
+            }
+          });
+        } else {
+          reject({ success: false });
+        }
+      });
+    });
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./create";
+export * from "./addTo";

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

@@ -0,0 +1,353 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+
+import { addToServiceDefinition } from "../src/addTo";
+
+import {
+  AddToFeatureServiceSuccessResponseFredAndGinger,
+  AddToFeatureServiceSuccessResponseFayardAndHarold,
+  AddToFeatureServiceSuccessResponseCydAndGene,
+  AddToFeatureServiceError
+} from "./mocks/service";
+
+import { layerDefinitionSid } from "./mocks/layerDefinition";
+
+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-common-types";
+
+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
+});