@openstax/ts-utils 1.12.3 → 1.14.0

package/dist/esm/errors/index.d.ts

@@ -1,3 +1,4 @@
+import type { JsonCompatibleStruct } from '../routing';
 /**
  * Returns true if the error is defined in this library
  */
@@ -17,6 +18,19 @@ export declare class InvalidRequestError extends Error {
     static matches: (e: any) => e is typeof InvalidRequestError;
     constructor(message?: string);
 }
+/**
+ * Validation Error
+ *
+ * `ValidationError.matches(error)` is a reliable way to check if an error is an
+ * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ValidationError extends Error {
+    static readonly TYPE = "ValidationError";
+    static matches: (e: any) => e is typeof ValidationError;
+    private data;
+    constructor(data: JsonCompatibleStruct);
+    getData(): JsonCompatibleStruct;
+}
 /**
  * Unauthorized error
  *

package/dist/esm/errors/index.js

@@ -30,6 +30,21 @@ export class InvalidRequestError extends Error {
 }
 InvalidRequestError.TYPE = 'InvalidRequestError';
 InvalidRequestError.matches = errorIsType(InvalidRequestError);
+/**
+ * Validation Error
+ *
+ * `ValidationError.matches(error)` is a reliable way to check if an error is an
+ * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export class ValidationError extends Error {
+    constructor(data) {
+        super(InvalidRequestError.TYPE);
+        this.data = data;
+    }
+    getData() { return this.data; }
+}
+ValidationError.TYPE = 'ValidationError';
+ValidationError.matches = errorIsType(ValidationError);
 /**
  * Unauthorized error
  *

package/dist/esm/middleware/apiErrorHandler.d.ts

@@ -1,8 +1,17 @@
+import { InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
 import type { ApiResponse } from '../routing';
 import type { Logger } from '../services/logger';
-declare type Handlers = {
-    [key: string]: (e: Error, logger: Logger) => ApiResponse<number, any>;
+export declare type DefaultErrors = {
+    UnauthorizedError: UnauthorizedError;
+    SessionExpiredError: SessionExpiredError;
+    NotFoundError: NotFoundError;
+    InvalidRequestError: InvalidRequestError;
+    ValidationError: ValidationError;
 };
+export declare type Handlers<E> = {
+    [T in keyof E]: (e: E[T], logger: Logger) => ApiResponse<number, any>;
+};
+export declare const defaultHandlers: Handlers<DefaultErrors>;
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,
  * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
@@ -11,5 +20,4 @@ declare type Handlers = {
  *
  * @param inputHandlers a map of errors to handler functions
  */
-export declare const createErrorHandler: (inputHandlers?: Handlers | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;
-export {};
+export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors> | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;

package/dist/esm/middleware/apiErrorHandler.js

@@ -1,11 +1,12 @@
 import { isAppError } from '../errors';
-import { apiTextResponse } from '../routing';
+import { apiJsonResponse, apiTextResponse } from '../routing';
 import { Level } from '../services/logger';
-const defaultHandlers = {
+export const defaultHandlers = {
     UnauthorizedError: () => apiTextResponse(401, '401 UnauthorizedError'),
     SessionExpiredError: () => apiTextResponse(440, '440 SessionExpiredError'),
     NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
     InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
+    ValidationError: (e) => apiJsonResponse(422, e.getData()),
 };
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,
@@ -21,6 +22,8 @@ export const createErrorHandler = (inputHandlers) => {
         const name = isAppError(e) ? e.constructor.TYPE : e.constructor.name;
         const handler = handlers[name];
         if (handler) {
+            // convincing typescript that this error is the right kind for the handler
+            // we looked up based on the errors name is very annoying
             return handler(e, logger);
         }
         logger.logEvent(Level.Error, {

package/dist/esm/routing/validators/zod.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+export declare const zodPayloadValidator: <T>(validator: z.ZodType<T, z.ZodTypeDef, T>) => (input: {
+    [key: string]: any;
+}) => input is T;

package/dist/esm/routing/validators/zod.js

@@ -0,0 +1,8 @@
+import { ValidationError } from '../../errors';
+export const zodPayloadValidator = (validator) => (input) => {
+    const result = validator.safeParse(input);
+    if (result.success) {
+        return true;
+    }
+    throw new ValidationError(result.error.format());
+};

package/dist/esm/services/accountsGateway/index.d.ts

@@ -1,7 +1,7 @@
 import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
 import { JsonCompatibleStruct } from '../../routing';
-import { ApiUser } from '../authProvider';
+import { ApiUser, ConsentPreferences } from '../authProvider';
 import { Logger } from '../logger';
 export declare type Config = {
     accountsBase: string;
@@ -60,6 +60,7 @@ export declare type SearchUsersResponse = {
     } & JsonCompatibleStruct>;
     total_count: number;
 };
+export declare type UpdateUserPayload = ConsentPreferences;
 export declare type MappedUserInfo<T> = {
     data: T;
     fullName: string;
@@ -78,6 +79,7 @@ export declare const accountsGateway: <C extends string = "accounts">(initialize
         [uuid: string]: T;
     }, logger: Logger, platformId?: string | undefined) => Promise<MappedUserInfo<T>[]>;
     searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
+    updateUser: (token: string, body: UpdateUserPayload) => Promise<ApiUser & JsonCompatibleStruct>;
 };
 export declare type AccountsGateway = ReturnType<ReturnType<typeof accountsGateway>>;
 export {};

package/dist/esm/services/accountsGateway/index.js

@@ -54,6 +54,7 @@ export const accountsGateway = (initializer) => (configProvider) => {
         }
     });
     const searchUsers = async (payload) => request(METHOD.GET, `users?${queryString.stringify(payload)}`, {});
+    const updateUser = async (token, body) => request(METHOD.PUT, 'user', { body, token });
     const getPlatformUserId = (externalIds, platformId) => {
         for (const externalId of externalIds) {
             const [userPlatformId, userId] = externalId.split('/', 2);
@@ -106,5 +107,5 @@ export const accountsGateway = (initializer) => (configProvider) => {
         }));
         return results;
     };
-    return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers };
+    return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers, updateUser };
 };

package/dist/esm/services/authProvider/index.d.ts

@@ -1,6 +1,12 @@
 import type { FetchConfig } from '../../fetch';
 import type { HttpHeaders, QueryParams } from '../../routing';
-export interface TokenUser {
+export declare type ConsentPreferences = {
+    consent_preferences: {
+        accepted: string[];
+        rejected: string[];
+    };
+};
+export declare type TokenUser = {
     id: number;
     name: string;
     first_name: string;
@@ -9,7 +15,7 @@ export interface TokenUser {
     uuid: string;
     faculty_status: string;
     is_administrator: boolean;
-}
+} & Partial<ConsentPreferences>;
 export interface ApiUser extends TokenUser {
     contact_infos: Array<{
         type: string;

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.js

@@ -24,7 +24,8 @@ export const embeddedAuthProvider = (getUserData, { authQuery, window }) => {
             ...params,
             ...extraParams,
             ...(authQuery && authQuery.value ? { [authQuery.key]: authQuery.value } : { auth: 'embedded' }),
-            [embeddedQueryKey]: embeddedQueryValue
+            [embeddedQueryKey]: embeddedQueryValue,
+            subcontent: 'true',
         });
         return url.href;
     };