feat: 🎸 added sdk handling kebab-case paths, fixed cli params

Author: prc5

packages/cli/src/cli/index.ts

@@ -39,9 +39,10 @@ const main = async () => {
           description: cmd.description(),
         })),
       });
+      await program.parseAsync([process.argv[0], process.argv[1], chosenCommand]);
+    } else {
+      await program.parseAsync(process.argv);
     }
-
-    await program.parseAsync([process.argv[0], process.argv[1], chosenCommand]);
   } catch (e) {
     handleError(e);
     if (e instanceof Error) {

packages/cli/src/codegen/openapi/generator.ts

@@ -117,20 +117,34 @@ export class OpenapiRequestGenerator {
       let currentLevel = schemaTree;
       // eslint-disable-next-line no-restricted-syntax
       for (const segment of segments) {
-        const key = segment.startsWith(":") ? `$${segment.slice(1)}` : segment;
+        let key: string;
+        if (segment.startsWith(":")) {
+          // Parameter segment - keep the $ prefix
+          key = `$${segment.slice(1)}`;
+        } else if (segment.includes("-")) {
+          // Convert kebab-case to camelCase for path segments
+          key = segment.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        } else {
+          key = segment;
+        }
+
         if (!currentLevel[key]) {
           currentLevel[key] = {};
         }
         currentLevel = currentLevel[key];
       }
-      currentLevel[method.toLowerCase()] = requestInstanceType;
+      // Prefix method names with $
+      currentLevel[`$${method.toLowerCase()}`] = requestInstanceType;
     });
 
     const sdkSchema = `export type SdkSchema<Client extends ClientInstance> = {\n${formatSchema(schemaTree)}\n}`;
 
     const createSdkFn = `
-export const createSdk = <Client extends ClientInstance>(client: Client) => {
-  return coreCreateSdk<Client, SdkSchema<Client>>(client);
+
+export type { Components };
+
+export const createSdk = <Client extends ClientInstance>(client: Client, options?: Parameters<typeof coreCreateSdk>[1] | undefined) => {
+  return coreCreateSdk<Client, SdkSchema<Client>>(client, options);
 };
 `;
 

packages/core/__tests__/features/sdk/sdk.base.spec.ts

@@ -11,25 +11,25 @@ type TestClient = Client<Error, HttpAdapterType>;
 
 type TestSchema = {
   users: {
-    get: RequestInstance<{
+    $get: RequestInstance<{
       client: TestClient;
       queryParams: { page: number; limit: number };
       endpoint: "/users";
     }>;
     $userId: {
-      get: RequestInstance<{
+      $get: RequestInstance<{
         client: TestClient;
         response: { id: string; name: string };
         endpoint: "/users/:userId";
       }>;
-      delete: RequestInstance<{
+      $delete: RequestInstance<{
         client: TestClient;
         response: { id: string; name: string };
         endpoint: "/users/:userId";
       }>;
       posts: {
         $postId: {
-          delete: RequestInstance<{
+          $delete: RequestInstance<{
             client: TestClient;
             response: { id: string; title: string };
             endpoint: "/users/:userId/posts/:postId";
@@ -38,6 +38,12 @@ type TestSchema = {
       };
     };
   };
+  acceptInvitation: {
+    $post: RequestInstance<{
+      client: TestClient;
+      endpoint: "/accept-invitation";
+    }>;
+  };
 };
 
 describe("SDK [ Base ]", () => {
@@ -60,7 +66,7 @@ describe("SDK [ Base ]", () => {
     const sdk = createSdk<TestClient, TestSchema>(client);
     expect(sdk).toBeDefined();
 
-    const request = sdk.users.$userId.get;
+    const request = sdk.users.$userId.$get;
 
     expect(request).toBeInstanceOf(Request);
     expect(request.method).toBe("GET");
@@ -71,7 +77,7 @@ describe("SDK [ Base ]", () => {
     const sdk = createSdk<TestClient, TestSchema>(client);
     expect(sdk).toBeDefined();
 
-    const request = sdk.users.$userId.posts.$postId.delete;
+    const request = sdk.users.$userId.posts.$postId.$delete;
 
     expect(request).toBeInstanceOf(Request);
     expect(request.method).toBe("DELETE");
@@ -82,7 +88,7 @@ describe("SDK [ Base ]", () => {
     const sdk = createSdk<TestClient, TestSchema>(client);
     expect(sdk).toBeDefined();
 
-    const request = sdk.users.$userId.get.setParams({ userId: "1" });
+    const request = sdk.users.$userId.$get.setParams({ userId: "1" });
 
     expect(request).toBeInstanceOf(Request);
     expect(request.endpoint).toBe("/users/1");
@@ -93,10 +99,32 @@ describe("SDK [ Base ]", () => {
     const sdk = createSdk<TestClient, TestSchema>(client);
     expect(sdk).toBeDefined();
 
-    const request = sdk.users.$userId.posts.$postId.delete.setParams({ userId: "1", postId: "2" });
+    const request = sdk.users.$userId.posts.$postId.$delete.setParams({ userId: "1", postId: "2" });
 
     expect(request).toBeInstanceOf(Request);
     expect(request.endpoint).toBe("/users/1/posts/2");
     expect(request.params).toEqual({ userId: "1", postId: "2" });
   });
+
+  it("should handle kebab-case to camelCase conversion", () => {
+    const sdk = createSdk<TestClient, TestSchema>(client, { camelCaseToKebabCase: true });
+    expect(sdk).toBeDefined();
+
+    const request = sdk.acceptInvitation.$post;
+
+    expect(request).toBeInstanceOf(Request);
+    expect(request.method).toBe("POST");
+    expect(request.endpoint).toBe("/accept-invitation");
+  });
+
+  it("should not handle kebab-case to camelCase conversion", () => {
+    const sdk = createSdk<TestClient, TestSchema>(client, { camelCaseToKebabCase: false });
+    expect(sdk).toBeDefined();
+
+    const request = sdk.acceptInvitation.$post;
+
+    expect(request).toBeInstanceOf(Request);
+    expect(request.method).toBe("POST");
+    expect(request.endpoint).toBe("/acceptInvitation");
+  });
 });

packages/core/src/sdk/sdk.ts

@@ -5,22 +5,51 @@ export type RecursiveSchemaType = Record<
   any
 >;
 
-const createRecursiveProxy = (client: ClientInstance, path: string[]): any => {
+export type CreateSdkOptions = {
+  /** @default true */
+  camelCaseToKebabCase?: boolean;
+  /** @default (method) => method.toUpperCase() */
+  methodTransform?: (method: string) => string;
+};
+
+const getMethod = (key: string, options?: CreateSdkOptions) => {
+  const { methodTransform = (method: string) => method.toUpperCase() } = options ?? {};
+  return methodTransform(key);
+};
+
+const createRecursiveProxy = (client: ClientInstance, path: string[], options?: CreateSdkOptions): any => {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   return new Proxy(() => {}, {
     get: (_target, key: string) => {
       if (typeof key === "symbol" || key === "inspect") {
         return undefined;
       }
 
-      // Assume the key is a method for the current path
+      // Check if this is a method (starts with $) or a path segment
+      let isMethod = false;
+      let methodName = key;
+      let pathSegment = key;
+
+      if (key.startsWith("$")) {
+        // This could be either a method or a parameter
+        // Try to determine by checking if it's a terminal access (method)
+        // For now, assume it's a method and strip the $ prefix
+        isMethod = true;
+        methodName = key.slice(1);
+        pathSegment = `:${key.slice(1)}`; // Convert to parameter format for path building
+      } else if (options?.camelCaseToKebabCase) {
+        // Convert camelCase to kebab-case for path segments if option is enabled
+        pathSegment = key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+      }
+
+      // Always create a request assuming this is a method call
       const endpoint = `/${path.join("/")}`;
-      const method = key.toUpperCase();
+      const method = getMethod(isMethod ? methodName : key, options);
       const request = client.createRequest()({ endpoint, method });
 
       // But also, assume the key is a new path segment for a deeper call
-      const newPath = [...path, key.startsWith("$") ? `:${key.slice(1)}` : key];
-      const deeperProxy = createRecursiveProxy(client, newPath);
+      const newPath = [...path, pathSegment];
+      const deeperProxy = createRecursiveProxy(client, newPath, options);
 
       // Return a new proxy that wraps both the request and the deeper proxy
       return new Proxy(request, {
@@ -39,6 +68,12 @@ const createRecursiveProxy = (client: ClientInstance, path: string[]): any => {
 
 export const createSdk = <Client extends ClientInstance, RecursiveSchema extends RecursiveSchemaType>(
   client: Client,
+  options?: CreateSdkOptions,
 ): RecursiveSchema => {
-  return createRecursiveProxy(client, []) as RecursiveSchema;
+  const {
+    camelCaseToKebabCase = true,
+    methodTransform = (method: string) => method.toUpperCase(),
+    ...rest
+  } = options ?? {};
+  return createRecursiveProxy(client, [], { camelCaseToKebabCase, methodTransform, ...rest }) as RecursiveSchema;
 };