@superblocksteam/sdk-api 2.0.99 → 2.0.100-next.1

package/src/integrations/cosmosdb/client.ts

@@ -97,24 +97,24 @@ export class CosmosDBClientImpl
     options?: CosmosDBQueryOptions,
     metadata?: TraceMetadata,
   ): Promise<T> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "sql",
-        value: {
-          action: {
-            case: "singleton",
-            value: {
-              containerId,
-              query: sql,
-              crossPartition: options?.crossPartition ?? false,
-              partitionKey: options?.partitionKey,
-            },
-          },
+    // Proto JSON format for: oneof cosmosdb_action { Sql sql = 5; }
+    // Sql.oneof action { Singleton singleton = 1; }
+    const request = {
+      sql: {
+        singleton: {
+          containerId,
+          query: sql,
+          crossPartition: options?.crossPartition ?? false,
+          partitionKey: options?.partitionKey,
         },
       },
     };
 
-    const result = await this.exec(request, "query", metadata);
+    const result = await this.exec(
+      request as unknown as Record<string, unknown>,
+      "query",
+      metadata,
+    );
     return this.validate(result, schema);
   }
 
@@ -125,20 +125,19 @@ export class CosmosDBClientImpl
     partitionKey?: string,
     metadata?: TraceMetadata,
   ): Promise<T> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "pointOperation",
-        value: {
-          containerId,
-          action: {
-            case: "read",
-            value: { id, partitionKey },
-          },
-        },
+    // Proto JSON format for: oneof cosmosdb_action { PointOperation point_operation = 6; }
+    const request = {
+      pointOperation: {
+        containerId,
+        read: { id, partitionKey },
       },
     };
 
-    const result = await this.exec(request, "read", metadata);
+    const result = await this.exec(
+      request as unknown as Record<string, unknown>,
+      "read",
+      metadata,
+    );
     return this.validate(result, schema);
   }
 
@@ -148,23 +147,21 @@ export class CosmosDBClientImpl
     partitionKey?: string,
     metadata?: TraceMetadata,
   ): Promise<unknown> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "pointOperation",
-        value: {
-          containerId,
-          action: {
-            case: "create",
-            value: {
-              body: typeof body === "string" ? body : JSON.stringify(body),
-              partitionKey,
-            },
-          },
+    const request = {
+      pointOperation: {
+        containerId,
+        create: {
+          body: typeof body === "string" ? body : JSON.stringify(body),
+          partitionKey,
         },
       },
     };
 
-    return this.exec(request, "create", metadata);
+    return this.exec(
+      request as unknown as Record<string, unknown>,
+      "create",
+      metadata,
+    );
   }
 
   async replace(
@@ -173,23 +170,21 @@ export class CosmosDBClientImpl
     partitionKey?: string,
     metadata?: TraceMetadata,
   ): Promise<unknown> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "pointOperation",
-        value: {
-          containerId,
-          action: {
-            case: "replace",
-            value: {
-              body: typeof body === "string" ? body : JSON.stringify(body),
-              partitionKey,
-            },
-          },
+    const request = {
+      pointOperation: {
+        containerId,
+        replace: {
+          body: typeof body === "string" ? body : JSON.stringify(body),
+          partitionKey,
         },
       },
     };
 
-    return this.exec(request, "replace", metadata);
+    return this.exec(
+      request as unknown as Record<string, unknown>,
+      "replace",
+      metadata,
+    );
   }
 
   async upsert(
@@ -198,23 +193,21 @@ export class CosmosDBClientImpl
     partitionKey?: string,
     metadata?: TraceMetadata,
   ): Promise<unknown> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "pointOperation",
-        value: {
-          containerId,
-          action: {
-            case: "upsert",
-            value: {
-              body: typeof body === "string" ? body : JSON.stringify(body),
-              partitionKey,
-            },
-          },
+    const request = {
+      pointOperation: {
+        containerId,
+        upsert: {
+          body: typeof body === "string" ? body : JSON.stringify(body),
+          partitionKey,
         },
       },
     };
 
-    return this.exec(request, "upsert", metadata);
+    return this.exec(
+      request as unknown as Record<string, unknown>,
+      "upsert",
+      metadata,
+    );
   }
 
   async deleteItem(
@@ -223,19 +216,17 @@ export class CosmosDBClientImpl
     partitionKey?: string,
     metadata?: TraceMetadata,
   ): Promise<unknown> {
-    const request: CosmosDBRequest = {
-      cosmosdbAction: {
-        case: "pointOperation",
-        value: {
-          containerId,
-          action: {
-            case: "delete",
-            value: { id, partitionKey },
-          },
-        },
+    const request = {
+      pointOperation: {
+        containerId,
+        delete: { id, partitionKey },
       },
     };
 
-    return this.exec(request, "delete", metadata);
+    return this.exec(
+      request as unknown as Record<string, unknown>,
+      "delete",
+      metadata,
+    );
   }
 }

package/src/integrations/declarations.test.ts

@@ -0,0 +1,64 @@
+import { describe, expectTypeOf, it } from "vitest";
+import {
+  mysql,
+  openai,
+  postgres,
+  slack,
+  type MySQLRef,
+  type OpenAIRef,
+  type PostgresRef,
+  type SlackRef,
+} from "./declarations.js";
+
+type LiteralString<T extends string> = string extends T ? never : T;
+type LiteralOnlyFactory<TRef> = <T extends string>(
+  id: LiteralString<T>,
+) => TRef;
+
+describe("LiteralString", () => {
+  it("preserves string literals", () => {
+    expectTypeOf<LiteralString<"abc-123">>().toEqualTypeOf<"abc-123">();
+  });
+
+  it("rejects broad string", () => {
+    expectTypeOf<LiteralString<string>>().toBeNever();
+  });
+});
+
+describe("integration declaration signatures", () => {
+  it("enforces literal-only postgres declarations", () => {
+    expectTypeOf(postgres).toEqualTypeOf<LiteralOnlyFactory<PostgresRef>>();
+  });
+
+  it("enforces literal-only slack declarations", () => {
+    expectTypeOf(slack).toEqualTypeOf<LiteralOnlyFactory<SlackRef>>();
+  });
+
+  it("enforces literal-only mysql declarations", () => {
+    expectTypeOf(mysql).toEqualTypeOf<LiteralOnlyFactory<MySQLRef>>();
+  });
+
+  it("enforces literal-only openai declarations", () => {
+    expectTypeOf(openai).toEqualTypeOf<LiteralOnlyFactory<OpenAIRef>>();
+  });
+});
+
+describe("integration declaration calls", () => {
+  it("accepts inline literals", () => {
+    const ref = postgres("a1b2c3d4-e5f6-7890-abcd-ef1234567890");
+
+    expectTypeOf(ref.pluginId).toEqualTypeOf<"postgres">();
+    expectTypeOf(ref.id).toBeString();
+  });
+
+  it("accepts const variables with preserved literal types", () => {
+    const PROD_DB = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+    const OPS_SLACK = "b2c3d4e5-f678-9012-abcd-ef1234567890";
+
+    const dbRef = postgres(PROD_DB);
+    const slackRef = slack(OPS_SLACK);
+
+    expectTypeOf(dbRef.pluginId).toEqualTypeOf<"postgres">();
+    expectTypeOf(slackRef.pluginId).toEqualTypeOf<"slack">();
+  });
+});