Sweep: split mutationMachine

[lveillard]

Details

Context:

• We already have queryMachine splitted between its typeDB and surrealDB machines. They can even work at once, as different entities can be defined in different databases and borm will fetch from the right source.

We need to do the same with the mutationMachine, which right now has only the typeDB mutation process

Todo:

• create a new file machine under the folder src/stateMachine/mutation/tql for typeQL with all the logic existing in src/stateMachine/mutation/mutationMachine.ts
• adapt mutationMachine.ts to use the resources from the new created file
• get inspired by src/stateMachine/query/queryMutation.ts which is already using the two databases, and has two machines (one in src/stateMachine/query/bql and another one in src/stateMachine/query/surql

Out of the scope:

• No need to build the machine for surrealDB, just a dummy file would do
• The mutation adapter of typeDB has to keep working, this is just a refacto to split the mutationMachine in two files to remove the direct dependencies

InspireBy what already works for the queries, as they are already split

• src/stateMachine/query/queryMachine.ts //the main file

• src/stateMachine/query/tql //the files for the tql machine

  • src/stateMachine/query/surql //the files for the surql machne

  Files to be changed:

  • src/stateMachine/mutation/mutateMachine.ts (remove the TQL query related parts and add the logic to tun the machines depending on the adapter, similar as it happens in - src/stateMachine/query/queryMachine.ts for the queries

  New files

  • src/stateMachine/mutation/suql/machine.ts //a dummy machine that does nothing
  • src/stateMachine/mutation/tql/machine.ts //the extracted typedb machine from mutateMacine

[sweep-ai[bot]]

Actions

• [ ] ↻ Restart Sweep

  ❌ Unable to Complete PR

  I'm sorry, but it looks like an error has occurred due to a code validation failure. The error message is /mnt/caches/repos/Blitzapps/blitz-orm/b5c947f78df2fb1ba92d2bf793f599bd04213d7d341e2a3490d9ff3c744ebf60/main/src/stateMachine/mutation/mutationMachine.ts does not exist.. Here were the changes I had planned:

src/stateMachine/mutation/tql/machine.ts

This is a new file that will contain the TypeDB mutation machine logic extracted from `src/stateMachine/mutation/mutationMachine.ts`. It will need the following: - Relevant imports from `src/stateMachine/mutation/mutationMachine.ts` - Type definitions used by the TypeDB mutation machine, such as `MachineContext` - Reducer functions used by the TypeDB mutation machine, such as `updateBqlReq`, `updateBqlRes`, etc. - Actor functions used by the TypeDB mutation machine, such as `enrich`, `preQuery`, `parseBQL`, etc. - The `machine` definition using the `createMachine` function - The `awaitMachine` and `runMutationMachine` functions

import { assertDefined } from '../../../helpers';
import type { BormConfig, DBHandles, EnrichedBormSchema, EnrichedBQLMutation, RawBQLMutation } from '../../../types';
import { createMachine, interpret, invoke, reduce, state, transition } from '../../robot3';
import { enrichBQLMutation } from '../bql/enrich';
import { parseBQLMutation } from '../bql/parse';
import { mutationPreQuery } from '../bql/preQuery';
import { buildTQLMutation } from './build';
import { parseTQLMutation } from './parse';
import { runTQLMutation } from './run';

export type TypeDbMachineContext = {
    bql: {
        raw: RawBQLMutation;
        current: EnrichedBQLMutation;
        things: any[];
        edges: any[];
        res: any[];
    };
    tql: {
        mutation?: any;
        res?: any;
    };
    schema: EnrichedBormSchema;
    config: BormConfig;
    handles: DBHandles;
    error?: string | null;
};

const updateBqlReq = (ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
    if (!event.data) {
        return ctx;
    }
    return {
        ...ctx,
        bql: { ...ctx.bql, current: event.data },
    };
};

const updateBqlRes = (ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
    if (!event.data) {
        return ctx;
    }
    return {
        ...ctx,
        bql: { ...ctx.bql, res: event.data },
    };
};

const updateThingsEdges = (ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
    return {
        ...ctx,
        bql: {
            ...ctx.bql,
            things: event.data.mergedThings,
            edges: event.data.mergedEdges,
        },
    };
};

const updateTQLMutation = (ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
    return {
        ...ctx,
        tql: {
            ...ctx.tql,
            mutation: event.data,
        },
    };
};

const updateTQLRes = (ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
    return {
        ...ctx,
        tql: {
            ...ctx.tql,
            res: event.data,
        },
    };
};

const enrich = async (ctx: TypeDbMachineContext) => {
    return enrichBQLMutation(ctx.bql.current, ctx.schema, ctx.config);
};

const preQuery = async (ctx: TypeDbMachineContext) => {
    return mutationPreQuery(ctx.bql.current, ctx.schema, ctx.config, ctx.handles);
};

const parseBQL = async (ctx: TypeDbMachineContext) => {
    return parseBQLMutation(ctx.bql.current, ctx.schema);
};

const buildMutation = async (ctx: TypeDbMachineContext) => {
    return buildTQLMutation(ctx.bql.things, ctx.bql.edges, ctx.schema);
};

const runMutation = async (ctx: TypeDbMachineContext) => {
    return runTQLMutation(assertDefined(ctx.tql.mutation), ctx.handles, ctx.config);
};

const parseMutation = async (ctx: TypeDbMachineContext) => {
    return parseTQLMutation(assertDefined(ctx.tql.res), ctx.bql.things, ctx.bql.edges, ctx.schema, ctx.config);
};

const errorTransition = transition(
    'error',
    'error',
    reduce((ctx: TypeDbMachineContext, event: any): TypeDbMachineContext => {
        return {
            ...ctx,
            error: event.error,
        };
    }),
);

export const typeDbMutationMachine = createMachine(
    'enrich',
    {
        enrich: invoke(enrich, transition('done', 'preQuery', reduce(updateBqlReq)), errorTransition),
        preQuery: invoke(preQuery, transition('done', 'parseBQL', reduce(updateBqlReq)), errorTransition),
        parseBQL: invoke(parseBQL, transition('done', 'buildMutation', reduce(updateThingsEdges)), errorTransition),
        buildMutation: invoke(buildMutation, transition('done', 'runMutation', reduce(updateTQLMutation)), errorTransition),
        runMutation: invoke(runMutation, transition('done', 'parseMutation', reduce(updateTQLRes)), errorTransition),
        parseMutation: invoke(parseMutation, transition('done', 'success', reduce(updateBqlRes)), errorTransition),
        success: state(),
        error: state(),
    },
    // @ts-expect-error Bad type
    (ctx: TypeDbMachineContext) => ctx,
);

const awaitMutationMachine = async (context: TypeDbMachineContext) => {
    return new Promise<any[]>((resolve, reject) => {
        // @ts-expect-error Bad type
        interpret(
            typeDbMutationMachine,
            // @ts-expect-error Bad type
            (service) => {
                if (service.machine.state.name === 'success') {
                    resolve(service.context.bql.res);
                }
                if (service.machine.state.name === 'error') {
                    reject(service.context.error);
                }
            },
            context,
        );
    });
};

export const runTypeDbMutationMachine = async (
    bql: RawBQLMutation,
    schema: EnrichedBormSchema,
    config: BormConfig,
    handles: DBHandles,
) => {
    return awaitMutationMachine({
        bql: {
            raw: bql,
            current: {} as EnrichedBQLMutation,
            things: [],
            edges: [],
            res: [],
        },
        tql: {},
        schema: schema,
        config: config,
        handles: handles,
        error: null,
    });
};

src/stateMachine/mutation/surql/machine.ts

This is a new file that will contain a dummy SurrealDB mutation machine. It will export a `runSurrealDbMutationMachine` function that does nothing.

export const runSurrealDbMutationMachine = async () => {
    // Dummy function, implementation out of scope
    return Promise.resolve([]);
};

src/stateMachine/mutation/mutationMachine.ts

Remove the imports related to the TypeDB mutation process, as they have been moved to `src/stateMachine/mutation/tql/machine.ts`.

--- 
+++ 
@@ -1,16 +1 @@
-import type {
-   BQLMutation,
-   BQLMutationBlock,
-   BormConfig,
-   DBHandles,
-   EnrichedBQLMutationBlock,
-   EnrichedBormSchema,
-} from '../../types';
-import { enrichBQLMutation } from './bql/enrich';
-import type { TqlMutation } from './tql/run';
-import { runTQLMutation } from './tql/run';
-import type { TqlRes } from './tql/parse';
-import { parseTQLMutation } from './tql/parse';
-import { parseBQLMutation } from './bql/parse';
-import { buildTQLMutation } from './tql/build';
-import { mutationPreQuery } from './bql/preQuery';
+import type { BQLMutation, BormConfig, DBHandles, EnrichedBormSchema } from '../../types';

src/stateMachine/mutation/mutationMachine.ts

Remove the reducer functions related to the TypeDB mutation process, as they have been moved to `src/stateMachine/mutation/tql/machine.ts`.

--- 
+++ 
@@ -1,48 +0,0 @@
-const updateBqlReq = (ctx: MachineContext, event: any) => {
-   if (!event.data) {
-       ///when preQueries return nothing, that should not affect the ctx
-       return ctx;
-   }
-   return {
-       ...ctx,
-       bql: { ...ctx.bql, current: event.data },
-   };
-};
-
-const updateBqlRes = (ctx: MachineContext, event: any) => {
-   return {
-       ...ctx,
-       bql: { ...ctx.bql, res: event.data },
-   };
-};
-
-const updateThingsEdges = (ctx: MachineContext, event: any) => {
-   return {
-       ...ctx,
-       bql: {
-           ...ctx.bql,
-           things: event.data.mergedThings,
-           edges: event.data.mergedEdges,
-       },
-   };
-};
-
-const updateTQLMutation = (ctx: MachineContext, event: any) => {
-   return {
-       ...ctx,
-       typeDB: {
-           ...ctx.typeDB,
-           tqlMutation: event.data,
-       },
-   };
-};
-
-const updateTQLRes = (ctx: MachineContext, event: any) => {
-   return {
-       ...ctx,
-       typeDB: {
-           ...ctx.typeDB,
-           tqlRes: event.data,
-       },
-   };
-};

src/stateMachine/mutation/mutationMachine.ts

Remove the actor functions related to the TypeDB mutation process, as they have been moved to `src/stateMachine/mutation/tql/machine.ts`.

--- 
+++ 
@@ -1,21 +0,0 @@
-const enrich = async (ctx: MachineContext) => {
-   return Object.keys(ctx.bql.current).length
-       ? enrichBQLMutation(ctx.bql.current, ctx.schema, ctx.config)
-       : enrichBQLMutation(ctx.bql.raw, ctx.schema, ctx.config);
-};
-
-const preQuery = async (ctx: MachineContext) => {
-   return mutationPreQuery(ctx.bql.current, ctx.schema, ctx.config, ctx.handles);
-};
-
-const preQueryDependencies = async (ctx: MachineContext) => {
-   return preHookDependencies(ctx.bql.current, ctx.schema, ctx.config, ctx.handles);
-};
-
-const parseBQL = async (ctx: MachineContext) => {
-   return parseBQLMutation(ctx.bql.current, ctx.schema);
-};
-
-const buildMutation = async (ctx: MachineContext) => {
-   return buildTQLMutation(ctx.bql.things, ctx.bql.edges, ctx.schema);
-};

src/stateMachine/mutation/mutationMachine.ts

Remove the TypeDB-specific parts of the `machine` definition, as they have been moved to `src/stateMachine/mutation/tql/machine.ts`.

--- 
+++ 
@@ -1,34 +1,68 @@
 export const machine = createMachine(
-   'stringify',
+   'adapter',
    {
-       stringify: invoke(
-           async (ctx: MachineContext) => stringify(ctx.bql.raw, ctx.schema),
-           transition('done', 'enrich', reduce(updateBqlReq)),
+       adapter: invoke(
+           async (ctx: MachineContext) => {
+               const adapters: Record<string, Adapter> = {};
+
+               ctx.bql.raw.forEach((block, i) => {
+                   const thing = getSchemaByThing(ctx.schema, block.$thing);
+                   const { id } = thing.defaultDBConnector;
+                   if (thing.db === 'typeDB') {
+                       if (!adapters[id]) {
+                           const client = ctx.handles.typeDB?.get(id)?.client;
+                           if (!client) {
+                               throw new Error(`TypeDB client with id "${thing.defaultDBConnector.id}" does not exist`);
+                           }
+                           adapters[id] = {
+                               db: 'typeDB',
+                               client,
+                               bqlMutation: [],
+                               indices: [],
+                           };
+                       }
+                   } else if (thing.db === 'surrealDB') {
+                       if (!adapters[id]) {
+                           const client = ctx.handles.surrealDB?.get(id)?.client;
+                           if (!client) {
+                               throw new Error(`SurrealDB client with id "${thing.defaultDBConnector.id}" does not exist`);
+                           }
+                           adapters[id] = {
+                               db: 'surrealDB',
+                               client,
+                               bqlMutation: [],
+                               indices: [],
+                           };
+                       }
+                   } else {
+                       throw new Error(`Unsupported DB "${thing.db}"`);
+                   }
+                   const adapter = adapters[id];
+                   adapter.bqlMutation.push(block);
+                   adapter.indices.push(i);
+               });
+
+               const adapterList = Object.values(adapters);
+               const proms = adapterList.map((a) => {
+                   if (a.db === 'typeDB') {
+                       return runTypeDbMutationMachine(a.bqlMutation, ctx.schema, ctx.config, ctx.handles);
+                   }
+                   return runSurrealDbMutationMachine();
+               });
+               const results = await Promise.all(proms);
+               const orderedResults = adapterList.flatMap((a, i) => {
+                   const result = results[i];
+                   return a.indices.map((index, j) => ({ index, result: result[j] }));
+               });
+               orderedResults.sort((a, b) => (a.index < b.index ? -1 : a.index > b.index ? 1 : 0));
+               const result = orderedResults.map(({ result }) => result);
+               return result;
+           },
+           transition('done', 'success', reduce(updateBqlRes)),
            errorTransition,
        ),
-       enrich: invoke(
-           enrich,
-           transition('done', 'preQuery', guard(requiresPreQuery), reduce(updateBqlReq)),
-           transition('done', 'parseBQL', reduce(updateBqlReq)),
-           errorTransition,
-       ),
-       preHookDependencies: invoke(
-           preQueryDependencies,
-           transition('done', 'enrich', reduce(updateBqlReq)),
-           errorTransition,
-       ),
-       preQuery: invoke(
-           preQuery,
-           transition('done', 'preHookDependencies', guard(requiresPreHookDependencies), reduce(updateBqlReq)),
-           transition('done', 'parseBQL', reduce(updateBqlReq)),
-           errorTransition,
-       ),
-       parseBQL: invoke(parseBQL, transition('done', 'buildMutation', reduce(updateThingsEdges)), errorTransition),
-       buildMutation: invoke(buildMutation, transition('done', 'runMutation', reduce(updateTQLMutation)), errorTransition),
-       runMutation: invoke(runMutation, transition('done', 'parseMutation', reduce(updateTQLRes)), errorTransition),
-       parseMutation: invoke(parseMutation, transition('done', 'success', reduce(updateBqlRes)), errorTransition),
-       success: final(),
-       error: final(),
+       success: state(),
+       error: state(),
    },
    // @ts-expect-error Bad type
    (ctx: MachineContext) => ctx,

src/stateMachine/mutation/mutationMachine.ts

Update the `awaitMachine` and `runMutationMachine` functions to match the updated `machine` definition.

--- 
+++ 
@@ -1,15 +1,15 @@
 export const awaitMachine = async (context: MachineContext) => {
-   return new Promise<MachineContext>((resolve, reject) => {
+   return new Promise<any[]>((resolve, reject) => {
        // @ts-expect-error Bad type
        interpret(
            machine,
            // @ts-expect-error Bad type
            (service) => {
                if (service.machine.state.name === 'success') {
-                   resolve(service.context);
+                   resolve(service.context.bql.res);
                }
                if (service.machine.state.name === 'error') {
-                   reject(service.context);
+                   reject(service.context.error);
                }
            },
            context,
@@ -26,19 +26,11 @@
    return awaitMachine({
        bql: {
            raw: mutation,
-           current: {} as EnrichedBQLMutationBlock,
-           things: [],
-           edges: [],
            res: [],
        },
-       typeDB: {
-           tqlMutation: {} as TqlMutation,
-           tqlRes: {} as TqlRes,
-       },
-       schema: schema as EnrichedBormSchema,
+       schema: schema,
        config: config,
        handles: handles,
-       depthLevel: 0,
        error: null,
    });
 };

src/stateMachine/mutation/mutationMachine.ts

Add the necessary imports for the `runTypeDbMutationMachine` and `runSurrealDbMutationMachine` functions.

--- 
+++ 
@@ -1,4 +1,3 @@
-import { createMachine, transition, reduce, guard, interpret, state, invoke } from '../robot3';
-import { stringify } from './bql/stringify';
-import { preHookDependencies } from './bql/enrichSteps/preHookDependencies';
-import { dependenciesGuard } from './bql/guards/dependenciesGuard';
+import { createMachine, transition, reduce, interpret, state, invoke } from '../robot3';
+import { runTypeDbMutationMachine } from './tql/machine';
+import { runSurrealDbMutationMachine } from './surql/machine';

Feel free to add more details to the issue description so Sweep can better address it. Alternatively, reach out to Kevin or William for help at https://community.sweep.dev/.

Report a bug.

---

[!TIP] To recreate the pull request, edit the issue title or description.

This is an automated message generated by Sweep AI.