@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/functions/entity-extraction/entity-extraction.test.ts

@@ -4,61 +4,37 @@
 
 import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
 
-import { AiService, MemoizedAiService } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Blueprint } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
-import { TestHelpers } from '@dxos/effect';
-import {
-  ComputeEventLogger,
-  CredentialsService,
-  DatabaseService,
-  FunctionInvocationService,
-  TracingService,
-} from '@dxos/functions';
-import { TestDatabaseLayer } from '@dxos/functions/testing';
-import { ObjectId, PublicKey } from '@dxos/keys';
-import { DataType } from '@dxos/schema';
+import { Database } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { ObjectId } from '@dxos/keys';
+import { Message, Organization, Person } from '@dxos/types';
 
-import { testToolkit } from '../../blueprints/testing';
-import { ResearchGraph } from '../research';
+import { OperationHandlerSet } from '@dxos/operation';
+
+import { ResearchGraph } from '../../blueprints';
 
 import { default as entityExtraction } from './entity-extraction';
 
 ObjectId.dangerouslyDisableRandomness();
 
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions([], testToolkit),
-  makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-  ComputeEventLogger.layerFromTracing,
-).pipe(
-  Layer.provideMerge(FunctionInvocationService.layerTest({ functions: [entityExtraction] })),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      MemoizedAiService.layerTest().pipe(Layer.provide(AiServiceTestingPreset('direct'))),
-      TestDatabaseLayer({
-        // TODO(dmaretskyi): define the constant space key in the test-builder.
-        spaceKey: PublicKey.from('665c420e0dec9aa36c2bedca567afb0778701920e346eaf83ab2bd3403859723'),
-        indexing: { vector: true },
-        types: [Blueprint.Blueprint, DataType.Message, DataType.Person, DataType.Organization, ResearchGraph],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  operationHandlers: OperationHandlerSet.make(entityExtraction),
+  types: [Blueprint.Blueprint, Message.Message, Person.Person, Organization.Organization, ResearchGraph.ResearchGraph],
+});
 
-describe.skip('Entity extraction', () => {
+describe('Entity extraction', () => {
   it.effect(
-    'call a function to generate a research report',
+    'calls a function to generate a research report',
     Effect.fnUntraced(
       function* (_) {
-        const email = yield* DatabaseService.add(
-          Obj.make(DataType.Message, {
+        const email = yield* Database.add(
+          Obj.make(Message.Message, {
             [Obj.Meta]: {
               tags: ['important'],
             },
@@ -83,7 +59,7 @@ describe.skip('Entity extraction', () => {
             ],
           }),
         );
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.flush();
         const result = yield* FunctionInvocationService.invokeFunction(entityExtraction, {
           source: email,
         });

package/src/functions/entity-extraction/entity-extraction.ts

@@ -2,105 +2,96 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Toolkit from '@effect/ai/Toolkit';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Predicate from 'effect/Predicate';
-import * as Schema from 'effect/Schema';
 
 import { AiService } from '@dxos/ai';
-import { AiSession, makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { DatabaseService, FunctionInvocationService, defineFunction } from '@dxos/functions';
+import { GenericToolkit } from '@dxos/ai';
+import { AiSession, ToolExecutionServices } from '@dxos/assistant';
+import { Database, Filter, Obj, Ref } from '@dxos/echo';
+import { FunctionInvocationService } from '@dxos/functions';
 import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Operation } from '@dxos/operation';
+import { type Actor, LegacyOrganization, Organization, Person } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { contextQueueLayerFromResearchGraph, makeGraphWriterHandler, makeGraphWriterToolkit } from '../research';
-
-export default defineFunction({
-  key: 'dxos.org/functions/entity-extraction',
-  name: 'Entity Extraction',
-  description: 'Extracts entities from emails and transcripts.',
-  inputSchema: Schema.Struct({
-    source: DataType.Message.annotations({ description: 'Email or transcript to extract entities from.' }),
-
-    // TODO(dmaretskyi): Consider making this an array of blueprints instead.
-    instructions: Schema.optional(Schema.String).annotations({ description: 'Instructions extraction process.' }),
-  }),
-  outputSchema: Schema.Struct({
-    entities: Schema.optional(
-      Schema.Array(Obj.Any).annotations({
-        description: 'Extracted entities.',
-      }),
-    ),
-  }),
-  handler: Effect.fnUntraced(
-    function* ({ data: { source, instructions } }) {
-      const contact = yield* extractContact(source);
-      let organization: DataType.Organization | null = null;
-
-      if (contact && !contact.organization) {
-        const created: DXN[] = [];
-        const GraphWriterToolkit = makeGraphWriterToolkit({ schema: [DataType.LegacyOrganization] }).pipe();
-        const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
-          onAppend: (dxns) => created.push(...dxns),
-        });
-        const toolkit = yield* GraphWriterToolkit.pipe(
-          Effect.provide(GraphWriterHandler.pipe(Layer.provide(contextQueueLayerFromResearchGraph))),
-        );
-
-        yield* new AiSession().run({
-          system: trim`
-            Extract the sender's organization from the email. If you are not sure, do nothing.
-            The extracted organization URL must match the sender's email domain.
-            ${instructions ? '<user_intructions>' + instructions + '</user_intructions>' : ''},
-          `,
-          prompt: JSON.stringify({ source, contact }),
-          toolkit,
-        });
-
-        if (created.length > 1) {
-          throw new Error('Multiple organizations created');
-        } else if (created.length === 1) {
-          organization = yield* DatabaseService.resolve(created[0], DataType.Organization);
-          Obj.getMeta(organization).tags ??= [];
-          Obj.getMeta(organization).tags!.push(...(Obj.getMeta(source)?.tags ?? []));
-          contact.organization = Ref.make(organization);
+import { EntityExtraction } from './definitions';
+import { ResearchGraph } from '../../blueprints';
+import { makeGraphWriterHandler, makeGraphWriterToolkit } from '../../crud';
+
+export default EntityExtraction.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ source: message, instructions }) {
+        const tags = Obj.getMeta(message)?.tags;
+        const contact = yield* extractContact(message.sender, tags);
+        let organization: Organization.Organization | null = null;
+
+        if (contact && !contact.organization) {
+          const created: DXN[] = [];
+          const GraphWriterToolkit = makeGraphWriterToolkit({
+            schema: [LegacyOrganization],
+          }).pipe();
+          const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
+            onAppend: (dxns) => created.push(...dxns),
+          });
+          const toolkit = yield* GraphWriterToolkit.pipe(
+            Effect.provide(GraphWriterHandler.pipe(Layer.provide(ResearchGraph.contextQueueLayer))),
+          );
+
+          yield* new AiSession().run({
+            system: trim`
+              Extract the sender's organization from the email. If you are not sure, do nothing.
+              The extracted organization URL must match the sender's email domain.
+              ${instructions ? '<user_intructions>' + instructions + '</user_intructions>' : ''},
+            `,
+            prompt: JSON.stringify({ source: message, contact }),
+            toolkit,
+          });
+
+          if (created.length > 1) {
+            throw new Error('Multiple organizations created');
+          } else if (created.length === 1) {
+            organization = yield* Database.resolve(created[0], Organization.Organization);
+            Obj.change(organization, (org) => {
+              const meta = Obj.getMeta(org);
+              meta.tags ??= [];
+              meta.tags.push(...(tags ?? []));
+            });
+            Obj.change(contact, (obj) => {
+              obj.organization = Ref.make(organization!);
+            });
+          }
         }
-      }
 
-      return {
-        entities: [contact, organization].filter(Predicate.isNotNullable),
-      };
-    },
-    Effect.provide(
-      Layer.mergeAll(
-        AiService.model('@anthropic/claude-sonnet-4-0'), // TODO(dmaretskyi): Extract.
-        makeToolResolverFromFunctions([], Toolkit.make()),
-        makeToolExecutionServiceFromFunctions(Toolkit.make() as any, Layer.empty as any),
-      ).pipe(
-        Layer.provide(
-          // TODO(dmaretskyi): This should be provided by environment.
-          Layer.mergeAll(FunctionInvocationService.layerTest()),
-        ),
+        return {
+          entities: [contact, organization].filter(Predicate.isNotNullable),
+        };
+      },
+      Effect.provide(
+        Layer.mergeAll(
+          AiService.model('@anthropic/claude-sonnet-4-0'), // TODO(dmaretskyi): Extract.
+          ToolExecutionServices,
+          FunctionInvocationService.layerNotAvailable,
+        ).pipe(Layer.provide(GenericToolkit.providerEmpty)),
       ),
     ),
   ),
-});
+  Operation.opaqueHandler,
+);
 
-const extractContact = Effect.fn('extractContact')(function* (message: DataType.Message) {
-  const name = message.sender.name;
-  const email = message.sender.email;
+const extractContact = Effect.fn('extractContact')(function* (actor: Actor.Actor, tags?: readonly string[]) {
+  const name = actor.name;
+  const email = actor.email;
   if (!email) {
-    log.warn('email is required for contact extraction', { sender: message.sender });
+    log.warn('email is required for contact extraction', { actor });
     return undefined;
   }
 
-  const { objects: existingContacts } = yield* DatabaseService.runQuery(Filter.type(DataType.Person));
+  const existingContacts = yield* Database.runQuery(Filter.type(Person.Person));
 
-  // Check for existing contact
   // TODO(dmaretskyi): Query filter DSL - https://linear.app/dxos/issue/DX-541/filtercontains-should-work-with-partial-objects
   const existingContact = existingContacts.find((contact) =>
     contact.emails?.some((contactEmail) => contactEmail.value === email),
@@ -111,16 +102,16 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
     return existingContact;
   }
 
-  const newContact = Obj.make(DataType.Person, {
-    [Obj.Meta]: {
-      tags: Obj.getMeta(message)?.tags,
-    },
+  const newContact = Obj.make(Person.Person, {
+    ...(tags ? { [Obj.Meta]: { tags: [...tags] } } : {}),
     emails: [{ value: email }],
   });
-  yield* DatabaseService.add(newContact);
+  yield* Database.add(newContact);
 
   if (name) {
-    newContact.fullName = name;
+    Obj.change(newContact, (obj) => {
+      obj.fullName = name;
+    });
   }
 
   const emailDomain = email.split('@')[1]?.toLowerCase();
@@ -131,7 +122,7 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
 
   log.info('extracted email domain', { emailDomain });
 
-  const { objects: existingOrganisations } = yield* DatabaseService.runQuery(Filter.type(DataType.Organization));
+  const existingOrganisations = yield* Database.runQuery(Filter.type(Organization.Organization));
   const matchingOrg = existingOrganisations.find((org) => {
     if (org.website) {
       try {
@@ -147,7 +138,10 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
           emailDomain.endsWith(`.${websiteDomain}`)
         );
       } catch (e) {
-        log.warn('Error parsing website URL', { website: org.website, error: e });
+        log.warn('Error parsing website URL', {
+          website: org.website,
+          error: e,
+        });
         return false;
       }
     }
@@ -156,7 +150,9 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
 
   if (matchingOrg) {
     log.info('found matching organization', { organization: matchingOrg });
-    newContact.organization = Ref.make(matchingOrg);
+    Obj.change(newContact, (obj) => {
+      obj.organization = Ref.make(matchingOrg);
+    });
   }
 
   return newContact;

package/src/functions/entity-extraction/index.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { default as extract$ } from './entity-extraction';
+import { OperationHandlerSet } from '@dxos/operation';
 
-export namespace EntityExtraction {
-  export const extract = extract$;
-}
+export * from './definitions';
+
+export const EntityExtractionHandlers = OperationHandlerSet.lazy(() => import('./entity-extraction'));

package/src/functions/exa/definitions.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { CredentialsService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+export const ExaSearch = Operation.make({
+  meta: {
+    key: 'org.dxos.function.exa-search',
+    name: 'Exa Search',
+    description: 'Search the web for information',
+  },
+  input: Schema.Struct({
+    query: Schema.String.annotations({
+      description: 'The query to search for.',
+    }),
+  }),
+  output: Schema.Unknown,
+  services: [CredentialsService],
+});
+
+export const ExaMock = Operation.make({
+  meta: {
+    key: 'org.dxos.function.exa-mock',
+    name: 'Exa mock',
+    description: 'Search the web for information',
+  },
+  input: Schema.Struct({
+    query: Schema.String.annotations({
+      description: 'The query to search for.',
+    }),
+  }),
+  output: Schema.Unknown,
+});

package/src/functions/exa/exa.ts

@@ -3,35 +3,30 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 import Exa from 'exa-js';
 
-import { CredentialsService, defineFunction } from '@dxos/functions';
+import { CredentialsService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  key: 'dxos.org/function/exa',
-  name: 'Exa',
-  description: 'Search the web for information',
-  inputSchema: Schema.Struct({
-    query: Schema.String.annotations({
-      description: 'The query to search for.',
-    }),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fnUntraced(function* ({ data: { query } }) {
-    const credential = yield* CredentialsService.getCredential({ service: 'exa.ai' });
-    const exa = new Exa(credential.apiKey);
+import { ExaSearch } from './definitions';
+
+export default ExaSearch.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ query }) {
+      const credential = yield* CredentialsService.getCredential({ service: 'exa.ai' });
+      const exa = new Exa(credential.apiKey);
 
-    const context = yield* Effect.promise(async () =>
-      exa.searchAndContents(query, {
-        type: 'auto',
-        text: {
-          maxCharacters: 3_000,
-        },
-        livecrawl: 'always',
-      }),
-    );
+      const context = yield* Effect.promise(async () =>
+        exa.searchAndContents(query, {
+          type: 'auto',
+          text: {
+            maxCharacters: 3_000,
+          },
+          livecrawl: 'always',
+        }),
+      );
 
-    return context;
-  }),
-});
+      return context;
+    }),
+  ),
+);

package/src/functions/exa/index.ts

@@ -2,5 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-export { default as exaFunction } from './exa';
-export { default as exaMockFunction } from './mock';
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const ExaHandlers = OperationHandlerSet.lazy(
+  () => import('./exa'),
+  () => import('./mock'),
+);

package/src/functions/exa/mock.ts

@@ -3,48 +3,39 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-import { SEARCH_RESULTS } from '../../testing';
+import { ExaMock } from './definitions';
+import { SEARCH_RESULTS } from './data';
 
-export default defineFunction({
-  key: 'dxos.org/function/exa-mock',
-  name: 'Exa mock',
-  description: 'Search the web for information',
-  inputSchema: Schema.Struct({
-    query: Schema.String.annotations({
-      description: 'The query to search for.',
-    }),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fnUntraced(function* ({ data: { query } }) {
-    const result = SEARCH_RESULTS.reduce(
-      (closest, current) => {
-        if (!current.autopromptString) {
-          return closest;
-        }
-        if (!closest) {
-          return current;
-        }
+export default ExaMock.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ query }) {
+      const result = SEARCH_RESULTS.reduce(
+        (closest, current) => {
+          if (!current.autopromptString) {
+            return closest;
+          }
+          if (!closest) {
+            return current;
+          }
 
-        // Calculate Levenshtein distance
-        const dist1 = levenshteinDistance(query, current.autopromptString);
-        const dist2 = levenshteinDistance(query, closest.autopromptString || '');
+          const dist1 = levenshteinDistance(query, current.autopromptString);
+          const dist2 = levenshteinDistance(query, closest.autopromptString || '');
 
-        // Weight by length of the longer string to normalize
-        const weight1 = dist1 / Math.max(query.length, current.autopromptString.length);
-        const weight2 = dist2 / Math.max(query.length, closest.autopromptString?.length || 0);
+          const weight1 = dist1 / Math.max(query.length, current.autopromptString.length);
+          const weight2 = dist2 / Math.max(query.length, closest.autopromptString?.length || 0);
 
-        return weight1 < weight2 ? current : closest;
-      },
-      null as (typeof SEARCH_RESULTS)[0] | null,
-    );
+          return weight1 < weight2 ? current : closest;
+        },
+        null as (typeof SEARCH_RESULTS)[0] | null,
+      );
 
-    return result;
-  }),
-});
+      return result;
+    }),
+  ),
+);
 
 const levenshteinDistance = (str1: string, str2: string): number => {
   const m = str1.length;

package/src/functions/index.ts

@@ -3,9 +3,5 @@
 //
 
 export * from './agent';
-export * from './discord';
-export * from './document';
 export * from './entity-extraction';
-export * from './linear';
-export * from './research';
-export * from './tasks';
+export * from './exa';

package/src/index.ts

@@ -3,6 +3,8 @@
 //
 
 export * from './blueprints';
+export * from './crud';
 export * from './functions';
-export * from './plugins';
 export * from './sync';
+export * from './toolkits';
+export * from './types';

package/src/sync/sync.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
+import { Database } from '@dxos/echo';
 import { failedInvariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
@@ -18,9 +18,12 @@ import { log } from '@dxos/log';
  * @param opts.foreignKeyId - The key to use for matching objects.
  */
 export const syncObjects: (
-  objs: Obj.Any[],
+  objs: Obj.Unknown[],
   opts: { foreignKeyId: string },
-) => Effect.Effect<Obj.Any[], never, DatabaseService> = Effect.fn('syncObjects')(function* (objs, { foreignKeyId }) {
+) => Effect.Effect<Obj.Unknown[], never, Database.Service> = Effect.fn('syncObjects')(function* (
+  objs,
+  { foreignKeyId },
+) {
   return yield* Effect.forEach(
     objs,
     Effect.fnUntraced(function* (obj) {
@@ -28,7 +31,7 @@ export const syncObjects: (
       for (const key of Object.keys(obj)) {
         if (typeof key !== 'string' || key === 'id') continue;
         if (!Ref.isRef((obj as any)[key])) continue;
-        const ref: Ref.Any = (obj as any)[key];
+        const ref: Ref.Unknown = (obj as any)[key];
         if (!ref.target) continue;
         if (Obj.getDXN(ref.target).isLocalObjectId()) {
           // obj not persisted to db.
@@ -39,9 +42,7 @@ export const syncObjects: (
 
       const schema = Obj.getSchema(obj) ?? failedInvariant('No schema.');
       const foreignId = Obj.getKeys(obj, foreignKeyId)[0]?.id ?? failedInvariant('No foreign key.');
-      const {
-        objects: [existing],
-      } = yield* DatabaseService.runQuery(
+      const [existing] = yield* Database.runQuery(
         Query.select(Filter.foreignKeys(schema, [{ source: foreignKeyId, id: foreignId }])),
       );
       log('sync object', {
@@ -50,7 +51,7 @@ export const syncObjects: (
         existing: existing ? Obj.getDXN(existing) : undefined,
       });
       if (!existing) {
-        yield* DatabaseService.add(obj);
+        yield* Database.add(obj);
         return obj;
       } else {
         copyObjectData(existing, obj);
@@ -61,27 +62,34 @@ export const syncObjects: (
   );
 });
 
-const copyObjectData = (existing: Obj.Any, newObj: Obj.Any) => {
-  for (const key of Object.keys(newObj)) {
-    if (typeof key !== 'string' || key === 'id') continue;
-    if (
-      typeof (newObj as any)[key] !== 'string' &&
-      typeof (newObj as any)[key] !== 'number' &&
-      typeof (newObj as any)[key] !== 'boolean' &&
-      !Ref.isRef((newObj as any)[key])
-    )
-      continue;
-    (existing as any)[key] = (newObj as any)[key];
-  }
-  for (const key of Object.keys(existing)) {
-    if (typeof key !== 'string' || key === 'id') continue;
-    if (!(key in newObj)) {
-      delete (existing as any)[key];
+const copyObjectData = (existing: Obj.Unknown, newObj: Obj.Unknown) => {
+  Obj.change(existing, (obj) => {
+    // Copy properties from newObj to existing.
+    for (const key of Object.keys(newObj)) {
+      if (typeof key !== 'string' || key === 'id') continue;
+      if (
+        typeof (newObj as any)[key] !== 'string' &&
+        typeof (newObj as any)[key] !== 'number' &&
+        typeof (newObj as any)[key] !== 'boolean' &&
+        !Ref.isRef((newObj as any)[key])
+      )
+        continue;
+      (obj as any)[key] = (newObj as any)[key];
     }
-  }
-  for (const foreignKey of Obj.getMeta(newObj).keys) {
-    Obj.deleteKeys(existing, foreignKey.source);
-    // TODO(dmaretskyi): Doesn't work: `Obj.getMeta(existing).keys.push(foreignKey);`
-    Obj.getMeta(existing).keys.push({ ...foreignKey });
-  }
+
+    // Delete properties that don't exist in newObj.
+    for (const key of Object.keys(obj)) {
+      if (typeof key !== 'string' || key === 'id') continue;
+      if (!(key in newObj)) {
+        delete (obj as any)[key];
+      }
+    }
+
+    // Update foreign keys.
+    for (const foreignKey of Obj.getMeta(newObj).keys) {
+      Obj.deleteKeys(obj, foreignKey.source);
+      // TODO(dmaretskyi): Doesn't work: `Obj.getMeta(existing).keys.push(foreignKey);`
+      Obj.getMeta(obj).keys.push({ ...foreignKey });
+    }
+  });
 };