Refactor call/yield to show their relationship

This allows strict types for the terms of what the procedure yields

Author: CarsonF

src/components/file/media/media.repository.ts

@@ -114,9 +114,11 @@ export class MediaRepository extends CommonRepository {
       // Update the labels if typename is given, and maybe changed.
       .apply((q) =>
         res
-          ? q
-              .call(apoc.create.setLabels('node', res.dbLabels))
-              .yield('node as labelsAdded')
+          ? q.call(
+              apoc.create
+                .setLabels('node', res.dbLabels)
+                .yield({ node: 'labelsAdded' }),
+            )
           : q,
       )
       // Grab the previous media node or null

src/components/product/product.repository.ts

@@ -552,7 +552,9 @@ export class ProductRepository extends CommonRepository {
       .query()
       .apply((q) =>
         query
-          ? q.apply(ProductCompletionDescriptionIndex.search(query))
+          ? q.call(
+              ProductCompletionDescriptionIndex.search(query).yield('node'),
+            )
           : q.matchNode('node', 'ProductCompletionDescription'),
       )
       .apply((q) =>

src/components/search/search.repository.ts

@@ -34,7 +34,7 @@ export class SearchRepository extends CommonRepository {
 
           .union()
 
-          .apply(GlobalIndex.search(lucene, { yield: 'node as property' }))
+          .call(GlobalIndex.search(lucene).yield({ node: 'property' }))
           .match([node('node'), relation('out', 'r', ACTIVE), node('property')])
           .return(['node', 'collect(type(r)) as matchedProps'])
           // The input.count is going to be applied once the results are 'filtered'

src/core/database/query-augmentation/call.ts

@@ -2,6 +2,7 @@ import { entries } from '@seedcompany/common';
 import { Clause, Query } from 'cypher-query-builder';
 import { Parameter } from 'cypher-query-builder/dist/typings/parameter-bag';
 import { isExp, variable } from '../query';
+import type { YieldTerms } from './yield';
 
 declare module 'cypher-query-builder/dist/typings/query' {
   interface Query {
@@ -22,16 +23,19 @@ Query.prototype.call = function call(
   procedure: ProcedureCall | string,
   args?: ProcedureArgs,
 ) {
-  const clause =
+  const call =
     typeof procedure === 'string'
-      ? new Procedure(procedure, args ?? [])
-      : new Procedure(procedure.name, procedure.args);
-  return this.continueChainClause(clause);
+      ? { procedureName: procedure, args: args ?? [] }
+      : procedure;
+  const clause = new Procedure(call.procedureName, call.args);
+  const next = this.continueChainClause(clause);
+  return call.yieldTerms ? next.yield(call.yieldTerms) : next;
 };
 
-interface ProcedureCall {
-  name: string;
+interface ProcedureCall<Y extends string = string> {
+  procedureName: string;
   args: ProcedureArgs;
+  yieldTerms?: YieldTerms<Y>;
 }
 type ProcedureArgs = Record<string, any> | any[];
 
@@ -51,3 +55,23 @@ class Procedure extends Clause {
     return `CALL ${this.name}(${this.params.join(', ')})`;
   }
 }
+
+export const procedure =
+  <const Y extends string>(
+    procedureName: string,
+    // eslint-disable-next-line @seedcompany/no-unused-vars
+    yieldDefs: readonly Y[],
+  ) =>
+  (args: ProcedureArgs) => ({
+    procedureName,
+    args,
+    yield: (yieldTerms: YieldTerms<Y>) =>
+      Object.assign(
+        (query: Query) => query.call(procedureName, args).yield(yieldTerms),
+        {
+          procedureName,
+          args,
+          yieldTerms,
+        },
+      ),
+  });

src/core/database/query-augmentation/yield.ts

@@ -1,14 +1,23 @@
-import { Many } from '@seedcompany/common';
+import { isPlainObject } from '@nestjs/common/utils/shared.utils.js';
+import { isNotFalsy, many, Many, Nil } from '@seedcompany/common';
 import { Clause, Query } from 'cypher-query-builder';
 
 declare module 'cypher-query-builder/dist/typings/query' {
   interface Query {
-    yield(...terms: Array<Many<string>>): this;
+    yield(terms: YieldTerms): this;
   }
 }
 
-Query.prototype.yield = function (this: Query, ...terms: Array<Many<string>>) {
-  const flattened = terms.flat();
+export type YieldTerms<T extends string = string> =
+  | Many<T | Nil>
+  | Partial<Record<T, string | boolean | Nil>>;
+
+Query.prototype.yield = function (this: Query, terms: YieldTerms) {
+  const flattened = isPlainObject(terms)
+    ? Object.entries(terms).flatMap(([k, v]) =>
+        v === false || v == null ? [] : v === true ? k : `${k} as ${v}`,
+      )
+    : many(terms).filter(isNotFalsy);
   if (flattened.length === 0) return this;
   return this.continueChainClause(new Yield(flattened));
 };

src/core/database/query/cypher-functions.ts

@@ -1,3 +1,4 @@
+import { procedure } from '../query-augmentation/call';
 import { exp, ExpressionInput } from './cypher-expression';
 import { IndexFullTextQueryNodes } from './full-text';
 
@@ -77,10 +78,8 @@ export const apoc = {
     toMap: fn1('apoc.convert.toMap'),
   },
   create: {
-    setLabels: (node: ExpressionInput, labels: readonly string[]) => ({
-      name: 'apoc.create.setLabels',
-      args: { node: exp(node), labels },
-    }),
+    setLabels: (node: ExpressionInput, labels: readonly string[]) =>
+      procedure('apoc.create.setLabels', ['node'])({ node: exp(node), labels }),
   },
 };
 

src/core/database/query/full-text.ts

@@ -2,6 +2,7 @@ import { entries, isNotNil, many, Many, mapKeys } from '@seedcompany/common';
 import { Query } from 'cypher-query-builder';
 import { pickBy } from 'lodash';
 import { LiteralUnion } from 'type-fest';
+import { procedure } from '../query-augmentation/call';
 import { CypherExpression, exp, isExp } from './cypher-expression';
 import { db } from './cypher-functions';
 
@@ -59,23 +60,17 @@ export const FullTextIndex = (config: {
      */
     search: (
       query: string,
-      config: {
-        yield?: Many<string>;
+      options: {
         skip?: number;
         limit?: number;
         analyzer?: Analyzer;
       } = {},
     ) => {
-      const { yield: yieldTerms = ['node'], ...options } = config;
-
       // fallback to "" when no query is given, so that no results are
       // returned instead of the procedure failing
       query = query.trim() || '""';
 
-      return (q: Query) =>
-        q
-          .call(db.index.fulltext.queryNodes(indexName, query, options))
-          .yield(yieldTerms);
+      return db.index.fulltext.queryNodes(indexName, query, options);
     },
   };
 };
@@ -95,17 +90,15 @@ export const IndexFullTextQueryNodes = (
         analyzer?: string;
       }
     | CypherExpression,
-) => ({
-  name: 'db.index.fulltext.queryNodes',
-  args: {
+) =>
+  procedure('db.index.fulltext.queryNodes', ['node', 'score'])({
     indexName,
     query,
     ...(options &&
     (Object.values(options).filter(isNotNil).length > 0 || isExp(options))
       ? { options }
       : undefined),
-  },
-});
+  });
 
 type Analyzer = LiteralUnion<KnownAnalyzer, string>;