reserve describe methodName for discoverableExo

Author: grypez

packages/kernel-utils/src/discoverable.test.ts

@@ -1,8 +1,16 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { makeDiscoverableExo } from './discoverable.ts';
 import type { MethodSchema } from './schema.ts';
 
+const makeExoMock = vi.hoisted(() =>
+  vi.fn((_name, _interfaceGuard, methods) => methods),
+);
+
+vi.mock('@endo/exo', () => ({
+  makeExo: makeExoMock,
+}));
+
 describe('makeDiscoverableExo', () => {
   const greetSchema: MethodSchema = {
     description: 'Greets a person by name',
@@ -113,4 +121,37 @@ describe('makeDiscoverableExo', () => {
       doSomething: schema.doSomething,
     });
   });
+
+  it('throws if describe is already a method', () => {
+    const methods = {
+      describe: () => 'original describe',
+      greet: (name: string) => `Hello, ${name}!`,
+    };
+    const schema: Record<keyof typeof methods, MethodSchema> = {
+      describe: {
+        description: 'Original describe method',
+        args: {},
+        returns: { type: 'string', description: 'Original description' },
+      },
+      greet: greetSchema,
+    };
+
+    expect(() => {
+      makeDiscoverableExo('TestExo', methods, schema);
+    }).toThrow('The `describe` method name is reserved for discoverable exos.');
+  });
+
+  it('re-throws errors from makeExo that are not about describe key', () => {
+    const testError = new Error('Some other error from makeExo');
+    makeExoMock.mockImplementation(() => {
+      throw testError;
+    });
+
+    const methods = { greet: (name: string) => `Hello, ${name}!` };
+    const schema = { greet: greetSchema };
+
+    expect(() => {
+      makeDiscoverableExo('TestExo', methods, schema);
+    }).toThrow('Some other error from makeExo');
+  });
 });

packages/kernel-utils/src/discoverable.ts

@@ -3,6 +3,7 @@ import type { Methods } from '@endo/exo';
 import type { InterfaceGuard } from '@endo/patterns';
 
 import { makeDefaultInterface } from './exo.ts';
+import { mergeDisjointRecords } from './merge-disjoint-records.ts';
 import type { MethodSchema } from './schema.ts';
 
 /**
@@ -50,14 +51,31 @@ export const makeDiscoverableExo = <
   methods: Interface,
   schema: Schema,
   interfaceGuard: InterfaceGuard = makeDefaultInterface(name),
-): DiscoverableExo<Interface, Schema> =>
-  // @ts-expect-error We're intentionally not specifying method-specific interface guards.
-  makeExo(name, interfaceGuard, {
-    ...methods,
-    /**
-     * Describe the methods of the discoverable.
-     *
-     * @returns A schema of the methods.
-     */
-    describe: () => schema,
-  });
+): DiscoverableExo<Interface, Schema> => {
+  try {
+    // @ts-expect-error We're intentionally not specifying method-specific interface guards.
+    return makeExo(
+      name,
+      interfaceGuard,
+      // @ts-expect-error We're intentionally not specifying method-specific interface guards.
+      mergeDisjointRecords(methods, {
+        /**
+         * Describe the methods of the discoverable.
+         *
+         * @returns A schema of the methods.
+         */
+        describe: () => schema,
+      }),
+    );
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.includes('Duplicate keys in records: describe')
+    ) {
+      throw new Error(
+        'The `describe` method name is reserved for discoverable exos.',
+      );
+    }
+    throw error;
+  }
+};