TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-12-12 05:12:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: remove old zitadel client

Browse Source
This commit is contained in:
Yordis Prieto
2024-07-25 23:16:07 -04:00
parent c2866b5d9d
commit 18851a0bbc
77 changed files with 6081 additions and 5616 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
packages/zitadel-client/.eslintrc.js → packages/zitadel-client/.eslintrc.cjs
View File

1
packages/zitadel-client/.gitignore vendored
View File

@@ -1 +0,0 @@
src/proto

14
packages/zitadel-client/buf.gen.yaml
View File

@@ -1,14 +0,0 @@
# buf.gen.yaml
version: v1
managed:
enabled: true
plugins:
# - plugin: buf.build/protocolbuffers/js
# out: src/app/proto/generated
# opt: import_style=commonjs,binary
- plugin: buf.build/grpc/web
out: src/proto/client
opt: import_style=typescript,mode=grpcweb
# - plugin: buf.build/grpc-ecosystem/openapiv2
# out: src/app/proto/generated
# opt: allow_delete_body

56
packages/zitadel-client/package.json
View File

@@ -1,37 +1,55 @@
{
"name": "@zitadel/client",
"version": "0.0.0",
"main": "./dist/index.js",
"module": "./dist/index.mjs",
"types": "./dist/index.d.ts",
"sideEffects": false,
"license": "MIT",
"private": true,
"publishConfig": {
"access": "public"
},
"type": "module",
"exports": {
".": {
"import": "./dist/index.js",
"require": "./dist/index.cjs",
"types": "./dist/index.d.ts"
},
"./v1": {
"import": "./dist/v1.js",
"require": "./dist/v1.cjs",
"types": "./dist/v1.d.ts"
},
"./v2beta": {
"import": "./dist/v2beta.js",
"require": "./dist/v2beta.cjs",
"types": "./dist/v2beta.d.ts"
},
"./v3alpha": {
"import": "./dist/v3alpha.js",
"require": "./dist/v3alpha.cjs",
"types": "./dist/v3alpha.d.ts"
}
},
"files": [
"dist/**"
],
"sideEffects": false,
"scripts": {
"generate": "buf generate https://github.com/zitadel/zitadel.git --path ./proto/zitadel",
"build": "tsup --dts",
"build": "tsup",
"test": "pnpm test:unit",
"test:watch": "pnpm test:unit:watch",
"test:unit": "vitest",
"test:unit:watch": "vitest --watch",
"dev": "tsup --watch --dts",
"lint": "eslint \"src/**/*.ts*\"",
"clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist && rm -rf src/proto"
},
"devDependencies": {
"@bufbuild/buf": "^1.14.0",
"@zitadel/tsconfig": "workspace:*",
"eslint-config-zitadel": "workspace:*",
"ts-proto": "^1.139.0"
},
"publishConfig": {
"access": "public"
"clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
},
"dependencies": {
"jose": "^4.13.1",
"nice-grpc-web": "^3.2.3",
"protobufjs": "^7.2.3"
"@zitadel/proto": "workspace:*",
"@bufbuild/protobuf": "^1.10.0",
"@connectrpc/connect": "^1.4.0"
},
"devDependencies": {
"@zitadel/tsconfig": "workspace:*",
"eslint-config-zitadel": "workspace:*"
}
}

45
packages/zitadel-client/src/app.ts
View File

@@ -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;
}

19
packages/zitadel-client/src/auth.ts
View File

@@ -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,
// ""
// );
}

8
packages/zitadel-client/src/helpers.ts Normal file
View File

@@ -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);
}

7
packages/zitadel-client/src/index.ts
View File

@@ -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";

80
packages/zitadel-client/src/interceptors.test.ts Normal file
View File

@@ -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",
);
});
});

16
packages/zitadel-client/src/interceptors.ts Normal file
View File

@@ -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);
};
}

76
packages/zitadel-client/src/middleware.test.ts
View File

@@ -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"),
);
});
});
});

14
packages/zitadel-client/src/middleware.ts
View File

@@ -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);
};

11
packages/zitadel-client/src/v1.ts Normal file
View File

@@ -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);

28
packages/zitadel-client/src/v2beta.ts Normal file
View File

@@ -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 },
};
}

8
packages/zitadel-client/src/v3alpha.ts Normal file
View File

@@ -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);

10
packages/zitadel-client/tsup.config.ts
View File

@@ -1,13 +1,13 @@
import { defineConfig, Options } from "tsup";
export default defineConfig((options: Options) => ({
treeshake: true,
splitting: true,
publicDir: true,
entry: ["src/index.ts", "src/**/index.ts"],
entry: ["src/index.ts", "src/v1.ts", "src/v2beta.ts", "src/v3alpha.ts"],
format: ["esm", "cjs"],
treeshake: false,
splitting: true,
dts: true,
minify: true,
minify: false,
clean: true,
sourcemap: true,
...options,
}));

12
packages/zitadel-client/turbo.json
View File

@@ -2,20 +2,14 @@
"extends": [
"//"
],
"pipeline": {
"generate": {
"outputs": [
"src/proto/**"
],
"cache": true
},
"tasks": {
"build": {
"outputs": [
"dist/**"
],
"dependsOn": [
"generate"
"@zitadel/proto#generate"
]
}
}
}
}