feat: allow apps to run any parser (DAP-4697)

Author: alsakhaev

libs/engine/src/app/contexts/mutable-web-context/use-mutation-parsers.ts

@@ -12,23 +12,9 @@ export const useMutationParsers = (engine: Engine, apps: AppMetadata[]) => {
     try {
       setIsLoading(true)
 
-      // ToDo: move to service
-      const uniqueNamespaces = Array.from(
-        new Set(
-          apps
-            .map((app) => app.targets?.map((target) => target.namespace))
-            .flat()
-            .filter((ns) => !!ns)
-        )
-      )
+      const parserConfigs = await engine.parserConfigService.getParserConfigsForApps(apps)
 
-      const parserConfigs = (
-        await Promise.all(
-          uniqueNamespaces.map((ns) => engine.parserConfigService.getParserConfig(ns))
-        )
-      ).filter((pc) => pc !== null)
-
-      setParserConfigs(parserConfigs as ParserConfig[])
+      setParserConfigs(parserConfigs)
     } catch (err) {
       if (err instanceof Error) {
         setError(err.message)

libs/engine/src/app/services/application/application.entity.ts

@@ -1,7 +1,10 @@
+import { ParserConfigId } from '../parser-config/parser-config.entity'
 import { Target } from '../target/target.entity'
 
 export type AppId = string
 
+export const AnyParserValue = 'any'
+
 export type AppMetadataTarget = Target & {
   static?: boolean
   componentId: string
@@ -14,6 +17,7 @@ export type AppMetadata = {
   authorId: string
   appLocalId: string
   targets: AppMetadataTarget[]
+  parsers?: typeof AnyParserValue | ParserConfigId[]
   controller?: string // BOS Widget ID
   metadata: {
     name?: string

libs/engine/src/app/services/application/application.repository.ts

@@ -82,6 +82,7 @@ export class ApplicationRepository {
     const storedAppMetadata = {
       [SelfKey]: JSON.stringify({
         targets: appMetadata.targets,
+        parsers: appMetadata.parsers,
       }),
       metadata: appMetadata.metadata,
     }

libs/engine/src/app/services/application/application.service.ts

@@ -1,13 +1,14 @@
 import { IContextNode } from '@mweb/core'
 import { MutationId } from '../mutation/mutation.entity'
 import { TargetService } from '../target/target.service'
-import { AppId, AppMetadata, AppWithSettings } from './application.entity'
+import { AnyParserValue, AppId, AppMetadata, AppWithSettings } from './application.entity'
 import { ApplicationRepository } from './application.repository'
 
 export class ApplicationService {
   constructor(private applicationRepository: ApplicationRepository) {}
 
   public getApplications(): Promise<AppMetadata[]> {
+    // ToDo: out of gas
     return this.applicationRepository.getApplications()
   }
 

libs/engine/src/app/services/parser-config/parser-config.repository.ts

@@ -6,10 +6,44 @@ const ParserKey = 'parser'
 const SettingsKey = 'settings'
 const SelfKey = ''
 const KeyDelimiter = '/'
+const WildcardKey = '*'
+const RecursiveWildcardKey = '**'
 
 export class ParserConfigRepository {
   constructor(private socialDb: SocialDbService) {}
 
+  async getAllParserConfigs(): Promise<ParserConfig[]> {
+    const keys = [
+      WildcardKey, // any author id
+      SettingsKey,
+      ProjectIdKey,
+      ParserKey,
+      WildcardKey, // any app local id
+    ]
+
+    const queryResult = await this.socialDb.get([
+      [...keys, RecursiveWildcardKey].join(KeyDelimiter),
+    ])
+
+    const parsersByKey = SocialDbService.splitObjectByDepth(queryResult, keys.length)
+
+    const parsers = Object.entries(parsersByKey).map(([key, parser]: [string, any]) => {
+      const [authorId, , , , appLocalId] = key.split(KeyDelimiter)
+      const globalParserId = [authorId, ParserKey, appLocalId].join(KeyDelimiter)
+
+      const config = JSON.parse(parser[SelfKey])
+
+      return {
+        id: globalParserId,
+        parserType: config.parserType,
+        contexts: config.contexts,
+        targets: config.targets,
+      }
+    })
+
+    return parsers
+  }
+
   async getParserConfig(globalParserId: string): Promise<ParserConfig | null> {
     if (globalParserId === 'mweb') return null
     const { accountId, parserLocalId } = this._extractParserIdFromNamespace(globalParserId)

libs/engine/src/app/services/parser-config/parser-config.service.ts

@@ -1,10 +1,37 @@
-import { ParserConfigId } from './parser-config.entity'
+import { AnyParserValue, AppMetadata } from '../application/application.entity'
+import { ParserConfig, ParserConfigId } from './parser-config.entity'
 import { ParserConfigRepository } from './parser-config.repository'
 
 export class ParserConfigService {
   constructor(private parserConfigRepository: ParserConfigRepository) {}
 
-  public async getParserConfig(parserId: ParserConfigId) {
+  public async getParserConfig(parserId: ParserConfigId): Promise<ParserConfig | null> {
     return this.parserConfigRepository.getParserConfig(parserId)
   }
+
+  public async getAllParserConfigs(): Promise<ParserConfig[]> {
+    // ToDo: out of gas
+    return this.parserConfigRepository.getAllParserConfigs()
+  }
+
+  public async getParserConfigsForApps(apps: AppMetadata[]): Promise<ParserConfig[]> {
+    const namespaces = new Set<ParserConfigId>()
+
+    for (const app of apps) {
+      if (!app.parsers) {
+        app.targets.forEach((target) => namespaces.add(target.namespace))
+      } else if (app.parsers === AnyParserValue) {
+        return this.getAllParserConfigs() // returns all parsers and breaks the loop!
+      } else {
+        app.parsers.forEach((parserGlobalId) => namespaces.add(parserGlobalId))
+      }
+    }
+
+    // ToDo: catch errors
+    const parserConfigs = await Promise.all(
+      Array.from(namespaces).map((ns) => this.getParserConfig(ns))
+    )
+
+    return parserConfigs.filter((pc) => pc !== null)
+  }
 }