@arpproject/recrate 0.1.2

package/src/crate-builder/RenderEntity/auto-complete.lib.ts

@@ -0,0 +1,184 @@
+import { isArray } from 'lodash';
+
+const defaultFields = ['@id', 'name'];
+const resultsLimit = 10;
+
+interface LookupConfig {
+  config: any;
+  lookup: any;
+  crateManager: any;
+}
+
+interface LookupResult {
+  endpoint: string;
+  documents: any[];
+}
+
+export class Lookup {
+  private config: any;
+  private lookup: any;
+  private crateManager: any;
+
+  constructor({ config, lookup, crateManager }: LookupConfig) {
+    this.config = config;
+    this.lookup = lookup;
+    this.crateManager = crateManager;
+  }
+
+  async getEntities(type: string, queryString: string): Promise<LookupResult> {
+    if (!queryString) return { endpoint: 'internal', documents: [] };
+
+    const results = await this.crateManager?.getEntities({
+      limit: resultsLimit,
+      type,
+      query: queryString,
+    });
+    const documents = stringifyDocumentType([...results]);
+
+    return {
+      endpoint: 'internal',
+      documents,
+    };
+  }
+
+  async dataPacks(type: string, queryString: string): Promise<LookupResult> {
+    if (!queryString) return { endpoint: 'datapacks', documents: [] };
+
+    type = isArray(type) ? type.join(', ') : type;
+    let fields, datapacks;
+    try {
+      ({ fields, datapacks } = this.config?.[type]);
+    } catch (error) {
+      fields = defaultFields;
+      datapacks = [];
+    }
+
+    const query = assembleQuery(type, fields, queryString);
+    const results = await this.lookup?.dataPacks({
+      type,
+      elasticQuery: query,
+      fields,
+      datapacks,
+      queryString,
+      limit: 10,
+    });
+
+    return {
+      endpoint: 'datapacks',
+      documents: stringifyDocumentType(results.documents),
+    };
+  }
+
+  async entities(type: string, queryString: string): Promise<LookupResult> {
+    if (!queryString) return { endpoint: 'entities', documents: [] };
+
+    type = isArray(type) ? type.join(', ') : type;
+    const fields = defaultFields;
+
+    const query = assembleQuery(type, fields, queryString);
+    const results = await this.lookup?.entities({
+      type,
+      elasticQuery: query,
+      fields,
+      queryString,
+      limit: 10,
+    });
+
+    return {
+      endpoint: 'entities',
+      documents: stringifyDocumentType(results.documents),
+    };
+  }
+
+  async entityTemplates(type: string, queryString: string): Promise<LookupResult> {
+    if (!queryString) return { endpoint: 'templates', documents: [] };
+
+    const results = await this.lookup?.entityTemplates({
+      type,
+      filter: queryString,
+      limit: resultsLimit,
+    });
+    return {
+      endpoint: 'templates',
+      documents: stringifyDocumentType(results.documents),
+    };
+  }
+
+  async ror(queryString: string): Promise<LookupResult> {
+    if (!queryString) return { endpoint: 'ror', documents: [] };
+
+    const api = 'https://api.ror.org/organizations';
+    let response = await fetch(`${api}?query.advanced=${queryString}`);
+    if (response.status !== 200) return { endpoint: 'ror', documents: [] };
+
+    const data = await response.json();
+    const results = data.items.slice(0, 10).map((item: any) => ({
+      '@id': item.id,
+      '@type': 'Organization',
+      name: item.name,
+    }));
+
+    return {
+      endpoint: 'ror',
+      documents: stringifyDocumentType(results),
+    };
+  }
+}
+
+export function awaitTimeout(delay: number, reason?: any): Promise<any> {
+  return new Promise((resolve) =>
+    setTimeout(() => (reason === undefined ? resolve(undefined) : resolve(reason)), delay)
+  );
+}
+
+export async function wrapPromise<T>(
+  promise: Promise<T>,
+  delay: number,
+  reason = { reason: 'Lookup Timeout' }
+): Promise<T> {
+  return Promise.race([promise, awaitTimeout(delay, reason)]);
+}
+
+function assembleQuery(type: string, fields: string[], queryString: string) {
+  const query = {
+    from: 0,
+    size: resultsLimit,
+    query: {
+      bool: {
+        must: [] as any[],
+      },
+    },
+  };
+
+  if (type !== 'ANY') {
+    query.query.bool.must.push({
+      match: {
+        '@type.keyword': {
+          query: type,
+          operator: 'and',
+        },
+      },
+    });
+  }
+
+  const shouldMatches = fields.map((field) => ({
+    match: {
+      [field]: { query: queryString, operator: 'and', fuzziness: 'AUTO' },
+    },
+  }));
+
+  query.query.bool.must.push({
+    bool: {
+      should: shouldMatches,
+    },
+  });
+
+  return query;
+}
+
+function stringifyDocumentType(documents: any[]) {
+  return documents.map((d) => ({
+    ...d,
+    '@type': isArray(d['@type']) ? d['@type'].join(', ') : d['@type'],
+  }));
+}

package/src/crate-builder/RenderEntity/keys.ts

@@ -0,0 +1,4 @@
+export const crateManagerKey = Symbol('crateManager');
+export const profileManagerKey = Symbol('profileManager');
+export const lookupsKey = Symbol('lookups');
+export const configurationKey = Symbol('configuration');