@timeback/powerpath 0.2.1 → 0.2.2-beta.20260331190459

package/dist/{chunk-5a9p0re1.js → chunk-setst1c6.js}

@@ -636,11 +636,11 @@ class TimebackProvider {
   env;
   auth;
   timeout;
-  endpoints;
-  authUrl;
-  tokenScope;
-  pathProfiles;
-  tokenManagers = new Map;
+  _endpoints;
+  _authUrl;
+  _tokenScope;
+  _pathProfiles;
+  _tokenManagers = new Map;
   constructor(config) {
     this.timeout = config.timeout ?? 30000;
     if (isEnvConfig(config)) {
@@ -653,89 +653,89 @@ class TimebackProvider {
       if (!platformEndpoints) {
         throw new Error(`Unknown platform: ${platform}`);
       }
-      this.authUrl = platformEndpoints.token[env];
-      this.tokenScope = platformEndpoints.tokenScope ?? undefined;
-      this.pathProfiles = PLATFORM_PATHS[platform] ?? BEYONDAI_PATHS;
-      this.endpoints = {
+      this._authUrl = platformEndpoints.token[env];
+      this._tokenScope = platformEndpoints.tokenScope ?? undefined;
+      this._pathProfiles = PLATFORM_PATHS[platform] ?? BEYONDAI_PATHS;
+      this._endpoints = {
         oneroster: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         edubridge: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         powerpath: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         clr: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         case: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         caliper: {
           baseUrl: platformEndpoints.caliper[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         webhooks: {
           baseUrl: platformEndpoints.caliper[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         reporting: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         qti: {
           baseUrl: platformEndpoints.qti[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         }
       };
     } else if (isExplicitConfig(config)) {
       this.auth = config.auth;
-      this.authUrl = config.authUrl;
-      this.pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
-      this.endpoints = {
-        oneroster: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        edubridge: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        powerpath: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        clr: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        case: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        caliper: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        webhooks: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        reporting: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        qti: { baseUrl: config.baseUrl, authUrl: this.authUrl }
+      this._authUrl = config.authUrl;
+      this._pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
+      this._endpoints = {
+        oneroster: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        edubridge: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        powerpath: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        clr: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        case: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        caliper: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        webhooks: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        reporting: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        qti: { baseUrl: config.baseUrl, authUrl: this._authUrl }
       };
     } else if (isServicesConfig(config)) {
       this.auth = config.auth;
-      this.authUrl = config.authUrl;
-      this.pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
-      this.endpoints = {};
+      this._authUrl = config.authUrl;
+      this._pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
+      this._endpoints = {};
       for (const [service, baseUrl] of Object.entries(config.services)) {
         if (baseUrl) {
-          this.endpoints[service] = {
+          this._endpoints[service] = {
             baseUrl,
-            authUrl: this.authUrl
+            authUrl: this._authUrl
           };
         }
       }
     } else {
       throw new Error("Invalid provider configuration");
     }
-    for (const service of Object.keys(this.pathProfiles)) {
-      if (this.pathProfiles[service] === null) {
-        delete this.endpoints[service];
+    for (const service of Object.keys(this._pathProfiles)) {
+      if (this._pathProfiles[service] === null) {
+        delete this._endpoints[service];
       }
     }
   }
   getEndpoint(service) {
-    const endpoint = this.endpoints[service];
+    const endpoint = this._endpoints[service];
     if (!endpoint) {
       const pathKey = service;
-      if (pathKey in this.pathProfiles && this.pathProfiles[pathKey] === null) {
+      if (pathKey in this._pathProfiles && this._pathProfiles[pathKey] === null) {
         throw new Error(`Service "${service}" is not supported on ${this.platform ?? "this"} platform.`);
       }
       throw new Error(`Service "${service}" is not configured in this provider`);
@@ -743,13 +743,13 @@ class TimebackProvider {
     return endpoint;
   }
   hasService(service) {
-    return service in this.endpoints;
+    return service in this._endpoints;
   }
   getAvailableServices() {
-    return Object.keys(this.endpoints);
+    return Object.keys(this._endpoints);
   }
   getTokenUrl() {
-    return this.authUrl;
+    return this._authUrl;
   }
   getEndpointWithPaths(service) {
     const endpoint = this.getEndpoint(service);
@@ -757,17 +757,17 @@ class TimebackProvider {
     return { ...endpoint, paths };
   }
   getPaths() {
-    return this.pathProfiles;
+    return this._pathProfiles;
   }
   getServicePaths(service) {
-    const paths = this.pathProfiles[service];
+    const paths = this._pathProfiles[service];
     if (!paths) {
       throw new Error(`Service "${service}" is not supported on ${this.platform ?? "this"} platform.`);
     }
     return paths;
   }
   hasServiceSupport(service) {
-    return this.pathProfiles[service] !== null;
+    return this._pathProfiles[service] !== null;
   }
   getTokenProvider(service) {
     const endpoint = this.getEndpoint(service);
@@ -778,7 +778,7 @@ class TimebackProvider {
     if (!this.auth) {
       throw new Error(`Service "${service}" requires authentication but no credentials were provided`);
     }
-    let manager = this.tokenManagers.get(authUrl);
+    let manager = this._tokenManagers.get(authUrl);
     if (!manager) {
       manager = new TokenManager({
         tokenUrl: authUrl,
@@ -786,28 +786,28 @@ class TimebackProvider {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
         },
-        scope: this.tokenScope
+        scope: this._tokenScope
       });
-      this.tokenManagers.set(authUrl, manager);
+      this._tokenManagers.set(authUrl, manager);
     }
     return manager;
   }
   async checkAuth() {
-    if (!this.authUrl || !this.auth) {
+    if (!this._authUrl || !this.auth) {
       throw new Error("No auth configured on this provider");
     }
     const startTime = Date.now();
-    let manager = this.tokenManagers.get(this.authUrl);
+    let manager = this._tokenManagers.get(this._authUrl);
     if (!manager) {
       manager = new TokenManager({
-        tokenUrl: this.authUrl,
+        tokenUrl: this._authUrl,
         credentials: {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
         },
-        scope: this.tokenScope
+        scope: this._tokenScope
       });
-      this.tokenManagers.set(this.authUrl, manager);
+      this._tokenManagers.set(this._authUrl, manager);
     }
     try {
       await manager.getToken();
@@ -826,10 +826,10 @@ class TimebackProvider {
     }
   }
   invalidateTokens() {
-    for (const manager of this.tokenManagers.values()) {
+    for (const manager of this._tokenManagers.values()) {
       manager.invalidate?.();
     }
-    this.tokenManagers.clear();
+    this._tokenManagers.clear();
   }
 }
 // ../../internal/client-infra/src/utils/utils.ts

package/dist/errors.d.ts

@@ -1 +1,144 @@
-export { ForbiddenError, InputValidationError, NotFoundError, ApiError as PowerPathError, UnauthorizedError, ValidationError } from '@timeback/internal-client-infra';
+/**
+ * Error Types
+ *
+ * Shared types for error helpers.
+ */
+/**
+ * Validation issue from client-side input validation.
+ */
+interface ValidationIssue {
+    /** Field path (e.g. "sourcedId", "metadata.email") */
+    path: string;
+    /** Human-readable error message */
+    message: string;
+}
+
+/**
+ * API Error Classes
+ *
+ * Base error classes for HTTP API failures.
+ * Includes IMS Global error response parsing (OneRoster, QTI, etc.).
+ */
+
+/**
+ * Base error class for all API errors.
+ *
+ * Provides access to the HTTP status code and raw response body.
+ * Includes IMS Global error parsing (minorCodes, details) for
+ * IMS-standard APIs like OneRoster and QTI.
+ *
+ * @example
+     * ```typescript
+     * // Catching and inspecting errors
+     * try {
+ *   await client.users.get('non-existent-id')
+ * } catch (error) {
+ *   if (error instanceof ApiError) {
+ *     console.log(`Error ${error.statusCode}: ${error.message}`)
+ *     console.log('Minor codes:', error.minorCodes)
+ *     console.log('Details:', error.details)
+ *   }
+ * }
+ * ```
+ */
+declare class ApiError extends Error {
+    readonly statusCode?: number | undefined;
+    readonly response?: unknown;
+    readonly name: string;
+    /**
+     * Creates a new ApiError.
+     *
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code
+     * @param response - Raw response body (if available)
+     */
+    constructor(message: string, statusCode?: number | undefined, response?: unknown);
+    /**
+     * Minor error codes from IMS Global error response.
+     *
+     * For IMS-standard APIs (OneRoster, QTI), provides specific error codes
+     * like "unknownobject" or "invaliddata".
+     *
+     * @returns Array of field/value pairs, or empty array if not IMS format
+     */
+    get minorCodes(): Array<{
+        field: string;
+        value: string;
+    }>;
+    /**
+     * Additional error details from IMS Global response.
+     *
+     * May contain field-level validation errors or other structured details.
+     *
+     * @returns Array of key-value objects, or empty array if not present
+     */
+    get details(): Array<Record<string, string>>;
+}
+/**
+ * Error thrown when authentication fails (HTTP 401).
+ *
+ * Typically indicates invalid or expired credentials.
+ */
+declare class UnauthorizedError extends ApiError {
+    readonly name = "UnauthorizedError";
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Error thrown when the client lacks permission for the operation (HTTP 403).
+ *
+ * The credentials are valid, but the client is not authorized for this action.
+ */
+declare class ForbiddenError extends ApiError {
+    readonly name = "ForbiddenError";
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Error thrown when a requested resource is not found (HTTP 404).
+ */
+declare class NotFoundError extends ApiError {
+    readonly name = "NotFoundError";
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Error thrown when request data is invalid (HTTP 422).
+ *
+ * Check the `details` property for field-level validation errors.
+ */
+declare class ValidationError extends ApiError {
+    readonly name = "ValidationError";
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Validation issue from client-side input validation.
+ */
+/**
+ * Error thrown when client-side input validation fails.
+ *
+ * This is thrown **before** making a network request, providing fast feedback
+ * with actionable, path-based error messages.
+ *
+ * Uses statusCode 400 (Bad Request) to distinguish from server-side 422 errors.
+ * Formats like IMS errors via `imsx_error_details` so existing error formatters work.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.users.create({}) // missing required fields
+ * } catch (error) {
+ *   if (error instanceof InputValidationError) {
+ *     console.log('Invalid input:', error.issues)
+ *     // [{ path: 'sourcedId', message: 'Required' }]
+ *   }
+ * }
+ * ```
+ */
+declare class InputValidationError extends ApiError {
+    readonly name = "InputValidationError";
+    /**
+     * The validation issues that caused this error.
+     */
+    readonly issues: ValidationIssue[];
+    constructor(message: string, issues: ValidationIssue[]);
+}
+
+export { ForbiddenError, InputValidationError, NotFoundError, ApiError as PowerPathError, UnauthorizedError, ValidationError };

package/dist/errors.js

@@ -5,7 +5,7 @@ import {
   NotFoundError,
   UnauthorizedError,
   ValidationError
-} from "./chunk-5a9p0re1.js";
+} from "./chunk-setst1c6.js";
 import"./chunk-6jf1natv.js";
 export {
   ValidationError,