Add types to query-suggestions' dependencies, import, and refactor to remove immutableJS

which is no longer needed for flatMap etc.

Author: jonathonherbert

kahuna/public/js/components/gr-cql-input/gr-cql-input.ts

@@ -26,7 +26,7 @@ grCqlInput.directive<
   "querySuggestions",
   function (querySuggestions: QuerySuggestionsService) {
     const fields: TypeaheadField[] = querySuggestions.typeaheadFields.map(
-      ({ fieldName, resolver }) => {
+      ({ fieldName, resolver, type = "TEXT" }) => {
         const mappedResolver = resolver
           ? async (fieldName: string) => {
               const suggestions = await (Array.isArray(resolver)
@@ -35,7 +35,7 @@ grCqlInput.directive<
 
               return suggestions.map((suggestion) => ({
                 label: suggestion,
-                value: suggestion
+                value: suggestion,
               }));
             }
           : undefined;
@@ -45,6 +45,7 @@ grCqlInput.directive<
           fieldName,
           undefined,
           mappedResolver,
+          type,
         );
       },
     );

kahuna/public/js/search/structured-query/query-suggestions.ts

@@ -1,16 +1,19 @@
 import * as angular from "angular";
-import { List, Map } from "immutable";
 
-import { mediaApi } from "../../services/api/media-api";
+import { MediaApi, mediaApi } from "../../services/api/media-api";
+import { EditsApi } from "../../services/api/edits-api";
 
 export const querySuggestions = angular.module("querySuggestions", [
-  mediaApi.name
+  mediaApi.name,
 ]);
 
 export type FieldAlias = {
+  elasticsearchPath: string;
+  label: string;
+  displayInAdditionalMetadata: boolean;
   displaySearchHint: boolean;
   alias: string;
-  searchHintOptions: any;
+  searchHintOptions: string[];
 };
 
 export type Chip = {
@@ -39,7 +42,7 @@ const subjects = [
   "social",
   "sport",
   "war",
-  "weather"
+  "weather",
 ];
 
 const fileTypes = ["jpeg", "tiff", "png"];
@@ -52,35 +55,28 @@ const isSearch = [
   `${staffPhotographerOrganisation}-owned-illustration`,
   `${staffPhotographerOrganisation}-owned`,
   "under-quota",
-  "deleted"
+  "deleted",
 ];
 
 if (window._clientConfig.useReaper === true) {
   isSearch.push("reapable");
 }
 
+type TypeaheadField = {
+  fieldName: string;
+  resolver?: ((value: string) => string[]) | string[];
+  type?: "DATE" | "TEXT";
+};
+
 export type QuerySuggestionsService = {
-  getChipSuggestions: (chip: Chip) => string[],
-  typeaheadFields: (
-    | {
-        fieldName: string;
-        resolver: (value: string) => string[];
-      }
-    | {
-        fieldName: string;
-        resolver?: undefined;
-      }
-    | {
-        fieldName: string;
-        resolver: string[];
-      }
-  )[];
+  getChipSuggestions: (chip: Chip) => string[];
+  typeaheadFields: TypeaheadField[];
 };
 
 querySuggestions.factory("querySuggestions", [
   "mediaApi",
   "editsApi",
-  function (mediaApi: any, editsApi: any): QuerySuggestionsService {
+  function (mediaApi: MediaApi, editsApi: EditsApi): QuerySuggestionsService {
     const fieldAliases = window._clientConfig.fieldAliases
       .filter((fieldAlias: FieldAlias) => fieldAlias.displaySearchHint === true)
       .reduce(
@@ -95,50 +91,50 @@ querySuggestions.factory("querySuggestions", [
       {
         fieldName: "by",
         resolver: (value: string) =>
-          listPhotographers().then(prefixFilter(value))
+          listPhotographers().then(prefixFilter(value)),
       },
       {
         fieldName: "category",
-        resolver: (value: string) => listCategories().then(prefixFilter(value))
+        resolver: (value: string) => listCategories().then(prefixFilter(value)),
       },
       { fieldName: "city" },
       { fieldName: "copyright" },
       { fieldName: "country" },
       {
         fieldName: "credit",
-        resolver: (value: string) => suggestCredit(value)
+        resolver: (value: string) => suggestCredit(value),
       },
       { fieldName: "description" },
       {
         fieldName: "fileType",
-        resolver: (value: string) => prefixFilter(value)(fileTypes)
+        resolver: (value: string) => prefixFilter(value)(fileTypes),
       },
       {
         fieldName: "illustrator",
         resolver: (value: string) =>
-          listIllustrators().then(prefixFilter(value))
+          listIllustrators().then(prefixFilter(value)),
       },
       { fieldName: "in" },
       { fieldName: "keyword" },
       {
         fieldName: "label",
-        resolver: (value: string) => suggestLabels(value)
+        resolver: (value: string) => suggestLabels(value),
       },
       { fieldName: "location" },
       { fieldName: "person" },
       {
         fieldName: "source",
-        resolver: (value: string) => suggestSource(value)
+        resolver: (value: string) => suggestSource(value),
       },
       { fieldName: "specialInstructions" },
       { fieldName: "state" },
       {
         fieldName: "subject",
-        resolver: (value: string) => prefixFilter(value)(subjects)
+        resolver: (value: string) => prefixFilter(value)(subjects),
       },
       {
         fieldName: "supplier",
-        resolver: (value: string) => listSuppliers().then(prefixFilter(value))
+        resolver: (value: string) => listSuppliers().then(prefixFilter(value)),
       },
       { fieldName: "suppliersReference" },
       { fieldName: "title" },
@@ -148,26 +144,35 @@ querySuggestions.factory("querySuggestions", [
       { fieldName: "usages@platform", resolver: listUsagePlatforms },
       {
         fieldName: "usages@status",
-        resolver: ["published", "pending", "removed"]
+        resolver: ["published", "pending", "removed"],
       },
       { fieldName: "usages@reference" },
       { fieldName: "has" },
       { fieldName: "croppedBy" },
       { fieldName: "filename" },
       {
         fieldName: "photoshoot",
-        resolver: (value: string) => suggestPhotoshoot(value)
+        resolver: (value: string) => suggestPhotoshoot(value),
       },
       { fieldName: "leasedBy" },
       { fieldName: "is", resolver: isSearch },
+      { fieldName: "dateTaken" } as const,
+      { fieldName: "date" },
       ...Object.keys(fieldAliases).map((fieldName) => ({
         fieldName,
         resolver: fieldAliases.hasOwnProperty(fieldName)
           ? (value: string) =>
               prefixFilter(value)(suggestFieldAliasOptions(fieldName))
-          : undefined
-      }))
-    ].sort();
+          : undefined,
+      })),
+    ].sort((a, b) => {
+      if (a.fieldName > b.fieldName) {
+        return 1;
+      } else if (a.fieldName === b.fieldName) {
+        return 0;
+      }
+      return -1;
+    }) as TypeaheadField[];
 
     const fieldNames = typeaheadFields.map((field) => field.fieldName);
 
@@ -178,88 +183,71 @@ querySuggestions.factory("querySuggestions", [
     }
 
     function listSuppliers() {
-      return editsApi
-        .getUsageRightsCategories()
-        .then(
-          (results: {
-            value: string;
-            properties: { name: string; options: any }[];
-          }) => {
-            return List<typeof results>(results)
-              .filter((res: any) => res.value === "agency")
-              .flatMap((res: any) => res.properties)
-              .filter(
-                (prop: { name: string; options: string }) =>
-                  prop.name === "supplier",
-              )
-              .flatMap((prop: { options: any }) => prop.options)
-              .toJS();
-          },
-        );
+      return editsApi.getUsageRightsCategories().then((results) => {
+        return results
+          .filter((res) => res.value === "agency")
+          .flatMap((res) => res.properties)
+          .filter((prop) => prop.name === "supplier")
+          .flatMap((prop) => prop.options);
+      });
     }
 
     function listCategories() {
       // TODO: would be nice to use user friendly labels and map
       // them to the key internally
-      return editsApi.getUsageRightsCategories().then((results: any) => {
-        return results
-          .map((res: any) => res.value)
-          .filter((key: string) => key !== ""); // no empty category
+      return editsApi.getUsageRightsCategories().then((results) => {
+        return results.map((res) => res.value).filter((key) => key !== ""); // no empty category
       });
     }
 
-    const photographerCategories = List.of(
+    const photographerCategories = [
       "staff-photographer",
       "contract-photographer",
-    );
+    ];
     function listPhotographers() {
-      return editsApi.getUsageRightsCategories().then((results: any) => {
-        return List(results)
-          .filter((res: any) => photographerCategories.includes(res.value))
-          .flatMap((res: any) => res.properties)
-          .filter((prop: { name: string }) => prop.name === "photographer")
-          .flatMap((prop: { optionsMap: any }) =>
-            Map(prop.optionsMap).valueSeq(),
-          )
-          .flatMap((list) => list)
-          .sort()
-          .toJS();
+      return editsApi.getUsageRightsCategories().then((results) => {
+        return results
+          .filter((res) => photographerCategories.includes(res.value))
+          .flatMap((res) => res.properties)
+          .filter((prop) => prop.name === "photographer")
+          .flatMap((prop) => Object.values(prop.optionsMap))
+          .flat()
+          .sort();
       });
     }
 
     function listIllustrators() {
-      return editsApi.getUsageRightsCategories().then((results: any) => {
-        return List(results)
-          .filter((res: any) => res.value === "contract-illustrator")
-          .flatMap((res: any) => res.properties)
-          .filter((prop: { name: string }) => prop.name === "creator")
-          .flatMap((prop: { options: any }) => prop.options)
-          .toJS();
+      return editsApi.getUsageRightsCategories().then((results) => {
+        return results
+          .filter((res) => res.value === "contract-illustrator")
+          .flatMap((res) => res.properties)
+          .filter((prop) => prop.name === "creator")
+          .flatMap((prop) => prop.options);
       });
     }
 
     function suggestCredit(prefix: string) {
       return mediaApi
         .metadataSearch("credit", { q: prefix })
-        .then((results: any) => results.data.map((res: any) => res.key));
+        .then((results) => results.data.map((res) => res.key));
     }
 
     function suggestSource(prefix: string) {
       return mediaApi
         .metadataSearch("source", { q: prefix })
-        .then((results: any) => results.data.map((res: any) => res.key));
+        .then((results) => results.data.map((res) => res.key));
     }
 
     function suggestLabels(prefix: string) {
       return mediaApi
         .labelsSuggest({ q: prefix })
-        .then((labels: any) => labels.data);
+        .then((labels) => labels.data);
     }
 
     function suggestPhotoshoot(prefix: string) {
       return mediaApi
         .metadataSearch("photoshoot", { q: prefix })
-        .then((results: any) => results.data.map((res: any) => res.key));
+        .then((results) => results.data.map((res) => res.key));
     }
 
     function listUsagePlatforms() {
@@ -301,7 +289,7 @@ querySuggestions.factory("querySuggestions", [
 
     return {
       typeaheadFields,
-      getChipSuggestions
+      getChipSuggestions,
     };
-  }
+  },
 ]);

kahuna/public/js/services/api/edits-api.js

@@ -5,6 +5,50 @@ export var editsApi = angular.module('kahuna.services.api.edits', [
     mediaApi.name
 ]);
 
+/**
+ * @typedef {{
+ *   value: string;
+ *   name: string;
+ *   cost: string;
+ *   description: string;
+ *   defaultRestrictions?: string;
+ *   caution?: string;
+ *   properties: UsageRightsProperty[];
+ *   leases: UsageRightsLease[];
+ *   usageRestrictions?: string;
+ *   usageSpecialInstructions?: string;
+ * }} CategoryResponse
+ */
+
+/**
+ * @typedef {{
+ *   name: string;
+ *   label: string;
+ *   type: string;
+ *   required: Boolean;
+ *   options?: string[];
+ *   optionsMap?: Record<string, string[]>;
+ *   optionsMapKey?: string;
+ *   examples?: string;
+ * }} UsageRightsProperty
+ */
+
+/**
+ * @typedef {{
+ *   category: string;
+ *   type: string;
+ *   startDate: string;
+ *   duration?: number;
+ *   notes?: string;
+ * }} UsageRightsLease
+ */
+
+/**
+ * @typedef {{
+ *  getUsageRightsCategories: () => Promise<CategoryResponse[]>
+ * }} EditsApi
+ */
+
 editsApi.factory('editsApi', ['$q', 'mediaApi', function($q, mediaApi) {
 
     var root;