@palantir/pack.auth 0.0.1-beta.1

package/src/types/UserRef.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Flavored, PackAppInternal } from "@palantir/pack.core";
+import type { AuthModule } from "./AuthModule.js";
+import { getAuthModule } from "./AuthModule.js";
+
+const UserRefBrand: unique symbol = Symbol("UserRef");
+export type UserId = Flavored<"pack:UserId">;
+
+/**
+ * Reference to a user from the platform API.
+ * Provides access to user information with caching.
+ */
+export interface UserRef {
+  readonly userId: UserId;
+  readonly [UserRefBrand]: typeof UserRefBrand;
+
+  /**
+   * Get the current user data from the platform API.
+   * Results are cached to avoid excessive API calls.
+   * @param force - Force refresh of cached data
+   */
+  readonly get: (force?: boolean) => Promise<unknown>;
+}
+
+const INVALID_USER_ID: UserId = "INVALID_USER_REF";
+const INVALID_USER_REF: UserRef = Object.freeze(
+  {
+    userId: INVALID_USER_ID,
+    [UserRefBrand]: UserRefBrand,
+    get: () => Promise.reject(new Error("Invalid user reference")),
+  } as const,
+);
+
+export function invalidUserRef(): UserRef {
+  return INVALID_USER_REF;
+}
+
+export function isValidUserRef(userRef: UserRef): boolean {
+  return userRef.userId !== INVALID_USER_ID && userRef.userId !== "";
+}
+
+export const createUserRef = (
+  app: PackAppInternal,
+  userId: UserId,
+): UserRef => {
+  return new UserRefImpl(app, userId);
+};
+
+class UserRefImpl implements UserRef {
+  readonly userId: UserId;
+  declare readonly [UserRefBrand]: typeof UserRefBrand;
+  readonly #authModule: AuthModule;
+
+  constructor(app: PackAppInternal, userId: UserId) {
+    this.#authModule = getAuthModule(app);
+    this.userId = userId;
+  }
+
+  get(force?: boolean): Promise<unknown> {
+    return this.#authModule.getUserData(this.userId, force);
+  }
+}

package/src/utils/AuthModuleConfig.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ModuleConfigTuple, ModuleKey } from "@palantir/pack.core";
+import { AUTH_MODULE_KEY } from "../constants/AuthModuleKey.js";
+import type { AuthModule } from "../types/AuthModule.js";
+import type { BaseAuthService } from "../types/BaseAuthService.js";
+
+/**
+ * Configuration for AuthModule initialization
+ */
+export interface AuthModuleConfig {
+  readonly authService: BaseAuthService;
+}
+
+/**
+ * Creates an auth module configuration tuple.
+ *
+ * @param authService - The auth service to use
+ * @returns Module configuration tuple for the auth module
+ */
+export function createAuthModuleConfig(
+  authService: BaseAuthService,
+): ModuleConfigTuple<AuthModule> {
+  const config: AuthModuleConfig = { authService };
+  return [AUTH_MODULE_KEY as ModuleKey<AuthModule>, config] as const;
+}

package/src/utils/AuthModuleImpl.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type PackAppInternal, type Unsubscribe } from "@palantir/pack.core";
+import type { AuthModule } from "../types/AuthModule.js";
+import type { AuthStateCallback } from "../types/AuthState.js";
+import { AuthState } from "../types/AuthState.js";
+import type { BaseAuthService } from "../types/BaseAuthService.js";
+import type { TokenChangeCallback } from "../types/TokenChange.js";
+import type { UserRef } from "../types/UserRef.js";
+import { createUserRef } from "../types/UserRef.js";
+
+export class AuthModuleImpl implements AuthModule {
+  readonly #authService: BaseAuthService;
+  private readonly app: PackAppInternal;
+  private signInPromise?: Promise<void>;
+
+  constructor(app: PackAppInternal, authService: BaseAuthService) {
+    this.app = app;
+    this.#authService = authService;
+  }
+
+  // AuthModule interface implementation
+  isAuthenticated(): boolean {
+    return this.#authService.isAuthenticated();
+  }
+
+  async getToken(): Promise<string> {
+    return this.#authService.getToken();
+  }
+
+  getTokenOrUndefined(): string | undefined {
+    return this.#authService.getTokenOrUndefined();
+  }
+
+  async signIn(): Promise<void> {
+    if (this.signInPromise) {
+      return this.signInPromise;
+    }
+
+    this.signInPromise = (async () => {
+      try {
+        await this.#authService.signIn();
+      } finally {
+        this.signInPromise = undefined;
+      }
+    })();
+
+    return this.signInPromise;
+  }
+
+  async signOut(): Promise<void> {
+    return this.#authService.signOut();
+  }
+
+  async refresh(): Promise<void> {
+    if (!this.#authService.refresh) {
+      throw new Error("Refresh not supported for this auth client type");
+    }
+
+    return this.#authService.refresh();
+  }
+
+  onAuthStateChange(callback: AuthStateCallback): Unsubscribe {
+    return this.#authService.onAuthStateChange(callback);
+  }
+
+  onTokenChange(callback: TokenChangeCallback): Unsubscribe {
+    return this.#authService.onTokenChange(callback);
+  }
+
+  async waitForAuth(): Promise<void> {
+    // If already authenticated, resolve immediately
+    if (this.isAuthenticated()) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      const unsubscribe = this.onAuthStateChange(event => {
+        if (event.state === AuthState.Authenticated) {
+          unsubscribe();
+          resolve();
+        } else if (event.state === AuthState.Error) {
+          unsubscribe();
+          reject(new Error("Authentication failed", { cause: event.error }));
+        }
+      });
+    });
+  }
+
+  getCurrentUser(): UserRef | undefined {
+    const userId = this.#authService.getCurrentUserId();
+    if (!userId) {
+      return undefined;
+    }
+    return createUserRef(this.app, userId);
+  }
+
+  async validateToken(): Promise<boolean> {
+    return this.#authService.validateToken();
+  }
+
+  async getUserData(userId: string, force?: boolean): Promise<unknown> {
+    return this.#authService.getUserData(userId, force);
+  }
+
+  dispose(): void {
+    this.#authService.dispose();
+    this.signInPromise = undefined;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "@palantir/pack.monorepo.tsconfig/base.json",
+  "compilerOptions": {
+    "outDir": "./build/esm",
+    "rootDir": "./src",
+    "declarationDir": "./build/types",
+    "tsBuildInfoFile": "./build/tsconfig.tsbuildinfo"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "build",
+    "dist",
+    "node_modules",
+    "test-output",
+    "**/__tests__/**/__snapshots__",
+    "**/__tests__/**/fixtures"
+  ],
+  "references": []
+}

package/vitest.config.mjs

@@ -0,0 +1,26 @@
+import { coverageConfigDefaults, defaultExclude, defineProject } from "vitest/config";
+
+export default defineProject({
+  test: {
+    exclude: [...defaultExclude, "**/build/**", "**/test-output/**"],
+    coverage: {
+      provider: "v8",
+      all: true,
+      enabled: true,
+      pool: "forks",
+      include: ["src/**/*.{ts,tsx}"],
+      exclude: [
+        ...coverageConfigDefaults.exclude,
+        "**/*.test.{ts,tsx}",
+        "**/__tests__",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "src/index.ts",
+        "test-output",
+        "vitest.config.*",
+      ],
+    },
+  },
+});