@treatwell/moleculer-call-wrapper 1.0.0

package/dist/index.cjs

@@ -0,0 +1,698 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var typescript = require('typescript');
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var crypto = require('node:crypto');
+var tsCloneNode = require('ts-clone-node');
+
+const MOLECULER_NAME = "m";
+function fillImports(context, sourceFile, node) {
+  node.forEachChild((n) => fillImports(context, sourceFile, n));
+  if (!typescript.isTypeReferenceNode(node)) {
+    return;
+  }
+  let nodeName = node.typeName.getText();
+  if (typescript.isQualifiedName(node.typeName)) {
+    nodeName = node.typeName.left.getText();
+  }
+  let importName = node.typeName.getText();
+  const importDeclaration = sourceFile.statements.filter(typescript.isImportDeclaration).find((n) => {
+    if (n.importClause?.namedBindings && typescript.isNamedImports(n.importClause.namedBindings)) {
+      const importIdentifier = n.importClause.namedBindings.elements.find(
+        (c) => c.name.getText() === nodeName
+      );
+      if (importIdentifier?.propertyName) {
+        importName = importIdentifier.propertyName.getText();
+      }
+      return !!importIdentifier;
+    }
+    return false;
+  });
+  if (importDeclaration) {
+    let key = importDeclaration.moduleSpecifier.getText().slice(1, -1);
+    if (key.startsWith(".")) {
+      key = `./${node_path.relative(
+        node_path.dirname(context.wrapperPath),
+        node_path.resolve(node_path.dirname(context.currentFilePath), key)
+      ).replace(/\\/g, "/")}`;
+    }
+    const name = addDepToImports(context.imports, key);
+    context.importMapping.set(node, `${name}.${importName}`);
+  }
+}
+function getUniqueNameFromKey(key) {
+  switch (key) {
+    case "@wavyapp/wavy-sdk":
+      return "sdk";
+    case "moleculer":
+      return MOLECULER_NAME;
+    default:
+      if (/^[a-zA-Z]\w+$/.test(key)) {
+        return key;
+      }
+      return `s${crypto.createHash("sha1").update(key).digest("hex").slice(0, 7)}`;
+  }
+}
+function addDepToImports(imports, key) {
+  let name = imports.get(key);
+  if (!name) {
+    name = getUniqueNameFromKey(key);
+    imports.set(key, name);
+  }
+  return name;
+}
+function importMappingCloneHook(importMapping) {
+  return (n) => {
+    if (typescript.isTypeReferenceNode(n) && importMapping.has(n)) {
+      return {
+        typeName: () => typescript.factory.createIdentifier(importMapping.get(n))
+      };
+    }
+    return void 0;
+  };
+}
+
+function parseService(context, service) {
+  const actions = [];
+  const sourceFile = typescript.createSourceFile(
+    "service.ts",
+    node_fs.readFileSync(context.currentFilePath, "utf8"),
+    typescript.ScriptTarget.ESNext,
+    true
+  );
+  const handlers = findActionsTypes(context, sourceFile);
+  const version = service.version ? `v${service.version}.` : "";
+  Object.entries(service.schema.actions || {}).forEach(
+    ([actionName, action]) => {
+      if (action === false || typeof action === "object" && action.visibility === "private") {
+        return;
+      }
+      const { params, returnType, typeParameters } = handlers.get(actionName) || {};
+      if (typeParameters) {
+        typeParameters.forEach((tp) => fillImports(context, sourceFile, tp));
+      }
+      if (returnType) {
+        fillImports(context, sourceFile, returnType);
+      }
+      if (params) {
+        fillImports(context, sourceFile, params);
+      }
+      actions.push({
+        actionName: `${version}${service.name}.${actionName}`,
+        params,
+        returnType,
+        typeParameters
+      });
+    }
+  );
+  context.builtins.forEach(
+    (injectBuiltin) => injectBuiltin(context, actions, service, sourceFile)
+  );
+  return actions;
+}
+function findActionsTypes(context, sourceFile) {
+  const handlers = /* @__PURE__ */ new Map();
+  function visit(n) {
+    if (!typescript.isMethodDeclaration(n) || n.name.getText() !== "handler" || n.parameters.length !== 1) {
+      return n.forEachChild(visit);
+    }
+    if (!typescript.isPropertyAssignment(n.parent.parent)) {
+      return n.forEachChild(visit);
+    }
+    const ctxType = n.parameters[0].type;
+    if (!ctxType || !typescript.isTypeReferenceNode(ctxType)) {
+      return n.forEachChild(visit);
+    }
+    let paramsType;
+    if (ctxType.typeArguments?.length && ctxType.typeArguments[0].getText() !== "never") {
+      [paramsType] = ctxType.typeArguments;
+    }
+    handlers.set(n.parent.parent.name.getText(), {
+      params: paramsType,
+      returnType: n.type,
+      typeParameters: n.typeParameters
+    });
+    return void 0;
+  }
+  sourceFile.forEachChild(visit);
+  return handlers;
+}
+
+const ParamsActions = "Actions";
+const NoParamsActions = "ActionsU";
+function createWrapperParameters(action, importMapping, actionTypeGenericName) {
+  let actionParamType;
+  if (actionTypeGenericName) {
+    actionParamType = typescript.factory.createTypeReferenceNode(
+      typescript.factory.createIdentifier(actionTypeGenericName),
+      void 0
+    );
+  } else if (action.actionName) {
+    actionParamType = typescript.factory.createLiteralTypeNode(
+      typescript.factory.createStringLiteral(action.actionName, true)
+    );
+  } else {
+    actionParamType = typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword);
+  }
+  return [
+    typescript.factory.createParameterDeclaration(
+      void 0,
+      void 0,
+      "ctx",
+      void 0,
+      typescript.factory.createTypeReferenceNode(`${MOLECULER_NAME}.Context`)
+    ),
+    typescript.factory.createParameterDeclaration(
+      void 0,
+      void 0,
+      "action",
+      void 0,
+      actionParamType
+    ),
+    typescript.factory.createParameterDeclaration(
+      void 0,
+      void 0,
+      "params",
+      action.params ? void 0 : typescript.factory.createToken(typescript.SyntaxKind.QuestionToken),
+      tsCloneNode.cloneNode(action.params, {
+        hook: importMappingCloneHook(importMapping)
+      }) || typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword)
+    ),
+    typescript.factory.createParameterDeclaration(
+      void 0,
+      void 0,
+      "meta",
+      typescript.factory.createToken(typescript.SyntaxKind.QuestionToken),
+      typescript.factory.createTypeReferenceNode(`${MOLECULER_NAME}.CallingOptions`)
+    )
+  ];
+}
+function createWrapperReturnType(action, importMapping) {
+  if (!action.returnType) {
+    return typescript.factory.createTypeReferenceNode("Promise", [
+      typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword)
+    ]);
+  }
+  if (typescript.isTypeReferenceNode(action.returnType) && action.returnType.getSourceFile() && action.returnType.typeName.getText() === "Promise") {
+    return tsCloneNode.cloneNode(action.returnType, {
+      hook: importMappingCloneHook(importMapping)
+    });
+  }
+  return typescript.factory.createTypeReferenceNode("Promise", [
+    tsCloneNode.cloneNode(action.returnType, {
+      hook: importMappingCloneHook(importMapping)
+    })
+  ]);
+}
+function createUnwrapReturnType(action, importMapping) {
+  if (!action.returnType) {
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword);
+  }
+  if (typescript.isTypeReferenceNode(action.returnType) && action.returnType.getSourceFile() && action.returnType.typeName.getText() === "Promise" && action.returnType.typeArguments?.length) {
+    return tsCloneNode.cloneNode(action.returnType.typeArguments[0], {
+      hook: importMappingCloneHook(importMapping)
+    });
+  }
+  return tsCloneNode.cloneNode(action.returnType, {
+    hook: importMappingCloneHook(importMapping)
+  });
+}
+function createWrapperTypeParameters(action, importMapping) {
+  if (!action.typeParameters) {
+    return [];
+  }
+  return action.typeParameters.map(
+    (tp) => tsCloneNode.cloneNode(tp, { hook: importMappingCloneHook(importMapping) })
+  );
+}
+function createWrapperFunctionOverload(action, importMapping, name, actionTypeGenericName, block) {
+  return typescript.factory.createFunctionDeclaration(
+    [typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)],
+    void 0,
+    name,
+    createWrapperTypeParameters(action, importMapping),
+    createWrapperParameters(action, importMapping, actionTypeGenericName),
+    createWrapperReturnType(action, importMapping),
+    block
+  );
+}
+function findUnusedTemplateName(action) {
+  const typeNames = new Set(action.typeParameters?.map((t) => t.name.getText()));
+  let actionTemplateName = "N";
+  while (typeNames.has(actionTemplateName)) {
+    actionTemplateName += "N";
+  }
+  return actionTemplateName;
+}
+function buildCallWrapperFile(actions, imports, importMapping) {
+  const stmts = [];
+  let sortedImports = [...imports.keys()].sort();
+  sortedImports = [
+    ...sortedImports.filter((d) => d.startsWith("@")),
+    ...sortedImports.filter((d) => !d.startsWith(".") && !d.startsWith("@")),
+    ...sortedImports.filter((d) => d.startsWith("."))
+  ];
+  for (const importPath of sortedImports) {
+    const importName = imports.get(importPath);
+    stmts.push(
+      typescript.factory.createImportDeclaration(
+        void 0,
+        typescript.factory.createImportClause(
+          true,
+          void 0,
+          typescript.factory.createNamespaceImport(typescript.factory.createIdentifier(importName))
+        ),
+        typescript.factory.createStringLiteral(importPath, true)
+      )
+    );
+  }
+  const sortedActions = actions.sort(
+    (a, b) => (a.actionName || "").localeCompare(b.actionName || "")
+  );
+  const actionsProperties = [];
+  const actionsNoParamsProperties = [];
+  stmts.push(
+    typescript.factory.createInterfaceDeclaration(
+      void 0,
+      typescript.factory.createIdentifier(ParamsActions),
+      void 0,
+      void 0,
+      actionsProperties
+    )
+  );
+  stmts.push(
+    typescript.factory.createInterfaceDeclaration(
+      void 0,
+      typescript.factory.createIdentifier(NoParamsActions),
+      void 0,
+      void 0,
+      actionsNoParamsProperties
+    )
+  );
+  const callTStmts = [];
+  const callStmts = [];
+  for (const action of sortedActions) {
+    if (action.typeParameters?.length) {
+      const templateTypes = createWrapperTypeParameters(action, importMapping);
+      if (action.params) {
+        const actionTemplateName = findUnusedTemplateName(action);
+        action.params = typescript.factory.createConditionalTypeNode(
+          typescript.factory.createTypeReferenceNode(
+            typescript.factory.createIdentifier(actionTemplateName),
+            void 0
+          ),
+          typescript.factory.createLiteralTypeNode(
+            typescript.factory.createStringLiteral(action.actionName || "", true)
+          ),
+          action.params,
+          typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword)
+        );
+        action.typeParameters = typescript.factory.createNodeArray([
+          ...templateTypes,
+          typescript.factory.createTypeParameterDeclaration(
+            void 0,
+            typescript.factory.createIdentifier(actionTemplateName),
+            typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword),
+            typescript.factory.createLiteralTypeNode(
+              typescript.factory.createStringLiteral(action.actionName || "", true)
+            )
+          )
+        ]);
+        callTStmts.push(
+          createWrapperFunctionOverload(
+            action,
+            importMapping,
+            "callT",
+            actionTemplateName
+          )
+        );
+      } else {
+        callStmts.push(
+          createWrapperFunctionOverload(action, importMapping, "call")
+        );
+      }
+    } else if (action.params) {
+      actionsProperties.push(
+        typescript.factory.createPropertySignature(
+          void 0,
+          typescript.factory.createStringLiteral(action.actionName || "", true),
+          void 0,
+          typescript.factory.createTupleTypeNode([
+            tsCloneNode.cloneNode(action.params, {
+              hook: importMappingCloneHook(importMapping)
+            }),
+            createUnwrapReturnType(action, importMapping)
+          ])
+        )
+      );
+    } else {
+      actionsNoParamsProperties.push(
+        typescript.factory.createPropertySignature(
+          void 0,
+          typescript.factory.createStringLiteral(action.actionName || "", true),
+          void 0,
+          createUnwrapReturnType(action, importMapping)
+        )
+      );
+    }
+  }
+  callStmts.push(
+    createWrapperFunctionOverload(
+      {
+        typeParameters: typescript.factory.createNodeArray([
+          typescript.factory.createTypeParameterDeclaration(
+            void 0,
+            typescript.factory.createIdentifier("N"),
+            typescript.factory.createTypeOperatorNode(
+              typescript.SyntaxKind.KeyOfKeyword,
+              typescript.factory.createTypeReferenceNode(
+                typescript.factory.createIdentifier(ParamsActions),
+                void 0
+              )
+            )
+          )
+        ]),
+        params: typescript.factory.createIndexedAccessTypeNode(
+          typescript.factory.createIndexedAccessTypeNode(
+            typescript.factory.createTypeReferenceNode(
+              typescript.factory.createIdentifier(ParamsActions)
+            ),
+            typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("N"))
+          ),
+          typescript.factory.createLiteralTypeNode(typescript.factory.createNumericLiteral("0"))
+        ),
+        returnType: typescript.factory.createIndexedAccessTypeNode(
+          typescript.factory.createIndexedAccessTypeNode(
+            typescript.factory.createTypeReferenceNode(
+              typescript.factory.createIdentifier(ParamsActions),
+              void 0
+            ),
+            typescript.factory.createTypeReferenceNode(
+              typescript.factory.createIdentifier("N"),
+              void 0
+            )
+          ),
+          typescript.factory.createLiteralTypeNode(typescript.factory.createNumericLiteral("1"))
+        )
+      },
+      importMapping,
+      "call",
+      "N"
+    )
+  );
+  callStmts.push(
+    createWrapperFunctionOverload(
+      {
+        typeParameters: typescript.factory.createNodeArray([
+          typescript.factory.createTypeParameterDeclaration(
+            void 0,
+            typescript.factory.createIdentifier("N"),
+            typescript.factory.createTypeOperatorNode(
+              typescript.SyntaxKind.KeyOfKeyword,
+              typescript.factory.createTypeReferenceNode(
+                typescript.factory.createIdentifier(NoParamsActions),
+                void 0
+              )
+            )
+          )
+        ]),
+        returnType: typescript.factory.createIndexedAccessTypeNode(
+          typescript.factory.createTypeReferenceNode(
+            typescript.factory.createIdentifier(NoParamsActions),
+            void 0
+          ),
+          typescript.factory.createTypeReferenceNode(
+            typescript.factory.createIdentifier("N"),
+            void 0
+          )
+        )
+      },
+      importMapping,
+      "call",
+      "N"
+    )
+  );
+  callStmts.push(
+    createWrapperFunctionOverload(
+      {
+        params: typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword),
+        returnType: typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword)
+      },
+      importMapping,
+      "call",
+      void 0,
+      typescript.factory.createBlock(
+        [
+          typescript.factory.createReturnStatement(
+            typescript.factory.createCallExpression(
+              typescript.factory.createPropertyAccessExpression(
+                typescript.factory.createIdentifier("ctx"),
+                typescript.factory.createIdentifier("call")
+              ),
+              void 0,
+              [
+                typescript.factory.createIdentifier("action"),
+                typescript.factory.createIdentifier("params"),
+                typescript.factory.createIdentifier("meta")
+              ]
+            )
+          )
+        ],
+        true
+      )
+    )
+  );
+  callTStmts.push(
+    createWrapperFunctionOverload(
+      {
+        params: typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword),
+        returnType: typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword)
+      },
+      importMapping,
+      "callT",
+      void 0,
+      typescript.factory.createBlock(
+        [
+          typescript.factory.createReturnStatement(
+            typescript.factory.createCallExpression(
+              typescript.factory.createPropertyAccessExpression(
+                typescript.factory.createIdentifier("ctx"),
+                typescript.factory.createIdentifier("call")
+              ),
+              void 0,
+              [
+                typescript.factory.createIdentifier("action"),
+                typescript.factory.createIdentifier("params"),
+                typescript.factory.createIdentifier("meta")
+              ]
+            )
+          )
+        ],
+        true
+      )
+    )
+  );
+  const printer = typescript.createPrinter({ newLine: typescript.NewLineKind.LineFeed });
+  const sourceFile = typescript.factory.createSourceFile(
+    [...stmts, ...callStmts, ...callTStmts],
+    typescript.factory.createToken(typescript.SyntaxKind.EndOfFileToken),
+    typescript.NodeFlags.Const
+  );
+  let res = printer.printFile(sourceFile);
+  res = res.replace(/interface Actions/, "\ninterface Actions").replace(/export function call/, "\nexport function call").replace(/export function callT/, "\nexport function callT");
+  const eslintIgnoreRules = [
+    "@typescript-eslint/no-explicit-any",
+    "@typescript-eslint/no-unused-vars"
+  ];
+  res = `/* eslint-disable ${eslintIgnoreRules.join(",")} */
+${res}`;
+  return res;
+}
+
+function injectDatabaseMixinV2Builtins(context, actions, service, sourceFile) {
+  const dbMixin = service.originalSchema.mixins?.find(
+    (m) => m.methods?._getDatabaseMixinCollection
+  );
+  if (!dbMixin) {
+    return;
+  }
+  const types = findDatabaseMixinTypes(context, sourceFile);
+  if (!types) {
+    return;
+  }
+  const typeArguments = types.tenantField ? [types.entityType, types.tenantField] : [types.entityType];
+  const version = service.version ? `v${service.version}.` : "";
+  const dbActions = actions.filter((a) => a.actionName?.startsWith(`${version}${service.name}.`)).filter((a) => !a.params || !a.returnType);
+  const importName = addDepToImports(
+    context.imports,
+    "@treatwell/moleculer-essentials"
+  );
+  for (const action of dbActions) {
+    const actionName = action.actionName?.replace(
+      `${version}${service.name}.`,
+      ""
+    );
+    if (!action.params) {
+      switch (actionName) {
+        case "find":
+        case "findStream": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionFindParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "getInternal": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionGetInternalParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "get": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionGetParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "countInternal": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionCountInternalParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "count": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionCountParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "list": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionListParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "create": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionCreateParams`,
+            [types.entityType]
+          );
+          break;
+        }
+        case "update": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionUpdateParams`,
+            typeArguments
+          );
+          break;
+        }
+        case "remove": {
+          action.params = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionRemoveParams`,
+            typeArguments
+          );
+          break;
+        }
+      }
+    }
+    if (!action.returnType) {
+      switch (actionName) {
+        case "find": {
+          action.returnType = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionFindResult`,
+            [types.entityType]
+          );
+          break;
+        }
+        case "findStream": {
+          const streamImportName = addDepToImports(context.imports, "stream");
+          action.returnType = typescript.factory.createTypeReferenceNode(
+            `${streamImportName}.Readable`
+          );
+          break;
+        }
+        case "countInternal":
+        case "count": {
+          action.returnType = typescript.factory.createKeywordTypeNode(
+            typescript.SyntaxKind.NumberKeyword
+          );
+          break;
+        }
+        case "list": {
+          action.returnType = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionListResult`,
+            [types.entityType]
+          );
+          break;
+        }
+        case "create":
+        case "update":
+        case "remove":
+        case "getInternal":
+        case "get": {
+          action.returnType = typescript.factory.createTypeReferenceNode(
+            `${importName}.DatabaseActionEntityResult`,
+            [types.entityType]
+          );
+          break;
+        }
+      }
+    }
+  }
+}
+function findDatabaseMixinTypes(context, sourceFile) {
+  let res;
+  function visit(n) {
+    if (!typescript.isCallExpression(n) || n.expression.getText() !== "DatabaseMethodsMixin") {
+      n.forEachChild(visit);
+      return;
+    }
+    if (!n.typeArguments?.length) {
+      return;
+    }
+    res = { entityType: n.typeArguments[0], tenantField: n.typeArguments[1] };
+  }
+  visit(sourceFile);
+  if (res) {
+    fillImports(context, sourceFile, res.entityType);
+    if (res.tenantField) {
+      fillImports(context, sourceFile, res.tenantField);
+    }
+  }
+  return res;
+}
+
+async function createWrapperCall(wrapperPath, services, svcFiles, additionalBuiltins) {
+  const currentContent = await promises.readFile(wrapperPath, "utf8");
+  const importMapping = /* @__PURE__ */ new Map();
+  const imports = /* @__PURE__ */ new Map();
+  addDepToImports(imports, "moleculer");
+  const builtins = [injectDatabaseMixinV2Builtins, ...additionalBuiltins];
+  const actions = services.flatMap(
+    (svc, idx) => parseService(
+      {
+        imports,
+        currentFilePath: svcFiles[idx],
+        wrapperPath,
+        importMapping,
+        builtins
+      },
+      svc
+    )
+  );
+  const wrapper = buildCallWrapperFile(actions, imports, importMapping);
+  if (currentContent !== wrapper && wrapper.trim()) {
+    await promises.writeFile(wrapperPath, wrapper);
+  }
+}
+
+exports.addDepToImports = addDepToImports;
+exports.createWrapperCall = createWrapperCall;
+exports.fillImports = fillImports;