fix: remove old zitadel client

packages/zitadel-client/src/app.ts

@@ -1,45 +0,0 @@
-/**
- * Return a slugified copy of a string.
- *
- * @param {CoreProps} str The ZITADEL client configuration
- * @return {Core} The client implementation.
- */
-
-let apps: ZitadelApp[] = [];
-
-export interface ZitadelCoreProps {
-  clientId: string;
-  apiUrl: string; // process.env.ZITADEL_API_URL
-  token: string;
-  adminToken?: string;
-  managementToken?: string;
-}
-
-export interface ZitadelOptions extends ZitadelCoreProps {
-  name?: string;
-}
-
-export interface ZitadelApp {
-  name: string | undefined;
-  config: ZitadelCoreProps;
-}
-
-export async function initializeApp(
-  config: ZitadelCoreProps,
-  name?: string,
-): Promise<ZitadelApp> {
-  const app = { config, name };
-  return app;
-}
-
-export function getApps(): ZitadelApp[] {
-  return apps;
-}
-
-export function getApp(name?: string): ZitadelApp | undefined {
-  return name
-    ? apps.find((a) => a.name === name)
-    : apps.length === 1
-      ? apps[0]
-      : undefined;
-}

packages/zitadel-client/src/auth.ts

@@ -1,19 +0,0 @@
-import { ZitadelApp } from "./app";
-import { authMiddleware } from "./middleware";
-
-// const createClient = <Client>(
-//   definition: CompatServiceDefinition,
-//   accessToken: string
-// ) => {
-//   const channel = createChannel(process.env.ZITADEL_API_URL ?? "");
-//   return createClientFactory()
-//     .use(authMiddleware(accessToken))
-//     .create(definition, channel) as Client;
-// };
-
-export async function getAuth(app?: ZitadelApp) {
-  //   return createClient<AuthServiceClient>(
-  //     AuthServiceDefinition as CompatServiceDefinition,
-  //     ""
-  //   );
-}

packages/zitadel-client/src/helpers.ts

@@ -0,0 +1,8 @@
+import { createPromiseClient, Transport } from "@connectrpc/connect";
+import type { ServiceType } from "@bufbuild/protobuf";
+
+export function createClientFor<TService extends ServiceType>(
+  service: TService,
+) {
+  return (transport: Transport) => createPromiseClient(service, transport);
+}

packages/zitadel-client/src/index.ts

@@ -1,5 +1,2 @@
-export { initializeApp, getApps } from "./app";
-
-export { getAuth } from "./auth";
-
-export type { ZitadelOptions } from "./app";
+export { NewAuthorizationBearerInterceptor } from "./interceptors";
+export type { PartialMessage, PlainMessage } from "@bufbuild/protobuf";

packages/zitadel-client/src/interceptors.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test, vitest } from "vitest";
+import { Int32Value, MethodKind, StringValue } from "@bufbuild/protobuf";
+import { createRouterTransport, HandlerContext } from "@connectrpc/connect";
+import { NewAuthorizationBearerInterceptor } from "./interceptors";
+
+const TestService = {
+  typeName: "handwritten.TestService",
+  methods: {
+    unary: {
+      name: "Unary",
+      I: Int32Value,
+      O: StringValue,
+      kind: MethodKind.Unary,
+    },
+  },
+} as const;
+
+describe("NewAuthorizationBearerInterceptor", () => {
+  const transport = {
+    interceptors: [NewAuthorizationBearerInterceptor("mytoken")],
+  };
+
+  test("injects the authorization token", async () => {
+    const handler = vitest.fn(
+      (request: Int32Value, context: HandlerContext) => {
+        return { value: request.value.toString() };
+      },
+    );
+
+    const service = createRouterTransport(
+      ({ service }) => {
+        service(TestService, { unary: handler });
+      },
+      { transport },
+    );
+
+    await service.unary(
+      TestService,
+      TestService.methods.unary,
+      undefined,
+      undefined,
+      {},
+      { value: 9001 },
+    );
+
+    expect(handler).toBeCalled();
+    expect(handler.mock.calls[0][1].requestHeader.get("Authorization")).toBe(
+      "Bearer mytoken",
+    );
+  });
+
+  test("do not overwrite the previous authorization token", async () => {
+    const handler = vitest.fn(
+      (request: Int32Value, context: HandlerContext) => {
+        return { value: request.value.toString() };
+      },
+    );
+
+    const service = createRouterTransport(
+      ({ service }) => {
+        service(TestService, { unary: handler });
+      },
+      { transport },
+    );
+
+    await service.unary(
+      TestService,
+      TestService.methods.unary,
+      undefined,
+      undefined,
+      { Authorization: "Bearer somethingelse" },
+      { value: 9001 },
+    );
+
+    expect(handler).toBeCalled();
+    expect(handler.mock.calls[0][1].requestHeader.get("Authorization")).toBe(
+      "Bearer somethingelse",
+    );
+  });
+});

packages/zitadel-client/src/interceptors.ts

@@ -0,0 +1,16 @@
+import type { Interceptor } from "@connectrpc/connect";
+
+/**
+ * Creates an interceptor that adds an Authorization header with a Bearer token.
+ * @param token
+ */
+export function NewAuthorizationBearerInterceptor(token: string): Interceptor {
+  return (next) => (req) => {
+    // TODO: I am not what is the intent of checking for the Authorization header
+    //  and setting it if it is not present.
+    if (!req.header.get("Authorization")) {
+      req.header.set("Authorization", `Bearer ${token}`);
+    }
+    return next(req);
+  };
+}

packages/zitadel-client/src/middleware.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, test, vitest } from "vitest";
-
-import {
-  CallOptions,
-  ClientMiddlewareCall,
-  Metadata,
-  MethodDescriptor,
-} from "nice-grpc-web";
-import { authMiddleware } from "./middleware";
-
-describe("authMiddleware", () => {
-  const scenarios = [
-    {
-      name: "should add authorization if metadata is undefined",
-      initialMetadata: undefined,
-      expectedMetadata: new Metadata().set(
-        "authorization",
-        "Bearer mock-token",
-      ),
-      token: "mock-token",
-    },
-    {
-      name: "should add authorization if metadata exists but no authorization",
-      initialMetadata: new Metadata().set("other-key", "other-value"),
-      expectedMetadata: new Metadata()
-        .set("other-key", "other-value")
-        .set("authorization", "Bearer mock-token"),
-      token: "mock-token",
-    },
-    {
-      name: "should not modify authorization if it already exists",
-      initialMetadata: new Metadata().set(
-        "authorization",
-        "Bearer initial-token",
-      ),
-      expectedMetadata: new Metadata().set(
-        "authorization",
-        "Bearer initial-token",
-      ),
-      token: "mock-token",
-    },
-  ];
-
-  scenarios.forEach(({ name, initialMetadata, expectedMetadata, token }) => {
-    test(name, async () => {
-      const mockNext = vitest.fn().mockImplementation(async function* () {});
-      const mockRequest = {};
-
-      const mockMethodDescriptor: MethodDescriptor = {
-        options: { idempotencyLevel: undefined },
-        path: "",
-        requestStream: false,
-        responseStream: false,
-      };
-
-      const mockCall: ClientMiddlewareCall<unknown, unknown> = {
-        method: mockMethodDescriptor,
-        requestStream: false,
-        responseStream: false,
-        request: mockRequest,
-        next: mockNext,
-      };
-      const options: CallOptions = {
-        metadata: initialMetadata,
-      };
-
-      await authMiddleware(token)(mockCall, options).next();
-
-      expect(mockNext).toHaveBeenCalledTimes(1);
-      const actualMetadata = mockNext.mock.calls[0][1].metadata;
-      expect(actualMetadata?.get("authorization")).toEqual(
-        expectedMetadata.get("authorization"),
-      );
-    });
-  });
-});

packages/zitadel-client/src/middleware.ts

@@ -1,14 +0,0 @@
-import { CallOptions, ClientMiddlewareCall, Metadata } from "nice-grpc-web";
-
-export const authMiddleware = (token: string) =>
-  async function* <Request, Response>(
-    call: ClientMiddlewareCall<Request, Response>,
-    options: CallOptions,
-  ) {
-    if (!options.metadata?.has("authorization")) {
-      options.metadata ??= new Metadata();
-      options.metadata?.set("authorization", `Bearer ${token}`);
-    }
-
-    return yield* call.next(call.request, options);
-  };

packages/zitadel-client/src/v1.ts

@@ -0,0 +1,11 @@
+import { createClientFor } from "./helpers";
+
+import { AdminService } from "@zitadel/proto/zitadel/admin_connect";
+import { AuthService } from "@zitadel/proto/zitadel/auth_connect";
+import { ManagementService } from "@zitadel/proto/zitadel/management_connect";
+import { SystemService } from "@zitadel/proto/zitadel/system_connect";
+
+export const createAdminServiceClient = createClientFor(AdminService);
+export const createAuthServiceClient = createClientFor(AuthService);
+export const createManagementServiceClient = createClientFor(ManagementService);
+export const createSystemServiceClient = createClientFor(SystemService);

packages/zitadel-client/src/v2beta.ts

@@ -0,0 +1,28 @@
+import type { PartialMessage } from "@bufbuild/protobuf";
+
+import { createClientFor } from "./helpers";
+import { UserService } from "@zitadel/proto/zitadel/user/v2beta/user_service_connect";
+import { SettingsService } from "@zitadel/proto/zitadel/settings/v2beta/settings_service_connect";
+import { SessionService } from "@zitadel/proto/zitadel/session/v2beta/session_service_connect";
+import { OIDCService } from "@zitadel/proto/zitadel/oidc/v2beta/oidc_service_connect";
+import { OrganizationService } from "@zitadel/proto/zitadel/org/v2beta/org_service_connect";
+import { FeatureService } from "@zitadel/proto/zitadel/feature/v2beta/feature_service_connect";
+import type { RequestContext } from "@zitadel/proto/zitadel/object/v2beta/object_pb";
+
+export const createUserServiceClient = createClientFor(UserService);
+export const createSettingsServiceClient = createClientFor(SettingsService);
+export const createSessionServiceClient = createClientFor(SessionService);
+export const createOIDCServiceClient = createClientFor(OIDCService);
+export const createOrganizationServiceClient =
+  createClientFor(OrganizationService);
+export const createFeatureServiceClient = createClientFor(FeatureService);
+
+export function makeReqCtx(
+  orgId: string | undefined,
+): PartialMessage<RequestContext> {
+  return {
+    resourceOwner: orgId
+      ? { case: "orgId", value: orgId }
+      : { case: "instance", value: true },
+  };
+}

packages/zitadel-client/src/v3alpha.ts

@@ -0,0 +1,8 @@
+import { createClientFor } from "./helpers";
+import { UserSchemaService } from "@zitadel/proto/zitadel/user/schema/v3alpha/user_schema_service_connect";
+import { UserService } from "@zitadel/proto/zitadel/user/v3alpha/user_service_connect";
+import { ActionService } from "@zitadel/proto/zitadel/action/v3alpha/action_service_connect";
+
+export const createUserSchemaServiceClient = createClientFor(UserSchemaService);
+export const createUserServiceClient = createClientFor(UserService);
+export const createActionServiceClient = createClientFor(ActionService);