@openstax/ts-utils 1.34.0 → 1.35.0

package/packages/utils/src/services/authProvider/utils/userRoleValidator.spec.ts

@@ -1,135 +0,0 @@
-import { stubAuthProvider } from '..';
-import { createUserRoleValidator, UserRoleValidator } from './userRoleValidator';
-
-describe('createUserRoleValidator', () => {
-
-  describe('with no user', () => {
-
-    let validator: UserRoleValidator;
-
-    beforeEach(() => {
-      const authProvider = stubAuthProvider(undefined);
-      validator = createUserRoleValidator(authProvider, {application: 'test'});
-    });
-
-    it('returns empty roles', async () => {
-      await expect(validator.getUserRoles()).resolves.toEqual([]);
-    });
-
-    it('says the user doesn\'t have given roles', async () => {
-      await expect(validator.userHasRole(['admin'])).resolves.toBe(false);
-    });
-
-    it('throws unauthorized', async () => {
-      await expect(validator.assertUserRole(['admin'])).rejects.toThrowErrorMatchingInlineSnapshot('"UnauthorizedError"');
-    });
-  });
-
-  describe('with user but no applications list', () => {
-
-    let validator: UserRoleValidator;
-
-    beforeEach(() => {
-      const authProvider = stubAuthProvider({
-        id: 3,
-        name: 'test user',
-        first_name: 'test',
-        last_name: 'user',
-        full_name: 'test user',
-        uuid: 'foo',
-        faculty_status: 'not faculty',
-        is_admin: false,
-      });
-      validator = createUserRoleValidator(authProvider, {application: 'test'});
-    });
-
-    it('returns empty roles', async () => {
-      await expect(validator.getUserRoles()).resolves.toEqual([]);
-    });
-
-    it('says the user doesn\'t have given roles', async () => {
-      await expect(validator.userHasRole(['admin'])).resolves.toBe(false);
-    });
-
-    it('throws unauthorized', async () => {
-      await expect(validator.assertUserRole(['admin'])).rejects.toThrowErrorMatchingInlineSnapshot('"UnauthorizedError"');
-    });
-  });
-
-  describe('with user and applications list, but missing given application', () => {
-
-    let validator: UserRoleValidator;
-
-    beforeEach(() => {
-      const authProvider = stubAuthProvider({
-        id: 3,
-        name: 'test user',
-        first_name: 'test',
-        last_name: 'user',
-        full_name: 'test user',
-        uuid: 'foo',
-        faculty_status: 'not faculty',
-        is_admin: false,
-        applications: [
-          {id: 123, name: 'not the one', roles: ['admin']},
-        ]
-      });
-      validator = createUserRoleValidator(authProvider, {application: 'test'});
-    });
-
-    it('returns roles list', async () => {
-      await expect(validator.getUserRoles()).resolves.toEqual([]);
-    });
-
-    it('says the user doesn\'t have given roles', async () => {
-      await expect(validator.userHasRole(['admin'])).resolves.toBe(false);
-    });
-
-    it('throws unauthorized', async () => {
-      await expect(validator.assertUserRole(['admin'])).rejects.toThrowErrorMatchingInlineSnapshot('"UnauthorizedError"');
-    });
-  });
-
-  describe('with user and applications list', () => {
-
-    let validator: UserRoleValidator;
-
-    beforeEach(() => {
-      const authProvider = stubAuthProvider({
-        id: 3,
-        name: 'test user',
-        first_name: 'test',
-        last_name: 'user',
-        full_name: 'test user',
-        uuid: 'foo',
-        faculty_status: 'not faculty',
-        is_admin: false,
-        applications: [
-          {id: 123, name: 'not the one', roles: ['admin']},
-          {id: 345, name: 'test', roles: ['member', 'manager']}
-        ]
-      });
-      validator = createUserRoleValidator(authProvider, {application: 'test'});
-    });
-
-    it('returns roles list', async () => {
-      await expect(validator.getUserRoles()).resolves.toEqual(['member', 'manager']);
-    });
-
-    it('says the user doesn\'t have given roles', async () => {
-      await expect(validator.userHasRole(['admin'])).resolves.toBe(false);
-    });
-
-    it('says the user has given roles', async () => {
-      await expect(validator.userHasRole(['member', 'other role'])).resolves.toBe(true);
-    });
-
-    it('allows assertion', async () => {
-      await expect(validator.assertUserRole(['manager', 'admin'])).resolves.not.toThrow();
-    });
-
-    it('throws unauthorized', async () => {
-      await expect(validator.assertUserRole(['admin'])).rejects.toThrowErrorMatchingInlineSnapshot('"UnauthorizedError"');
-    });
-  });
-});

package/packages/utils/src/services/authProvider/utils/userRoleValidator.ts

@@ -1,49 +0,0 @@
-import { AuthProvider } from '..';
-import { AssertionFailed, doThrow } from '../../../assertions';
-import { ConfigProviderForConfig } from '../../../config';
-import { resolveConfigValue } from '../../../config/resolveConfigValue';
-import { UnauthorizedError } from '../../../errors';
-import { once } from '../../../misc/helpers';
-
-type Config = {
-  application: string;
-};
-
-export const createUserRoleValidator = (auth: AuthProvider, config: ConfigProviderForConfig<Config>) => {
-  const application = once(() => resolveConfigValue(config.application));
-
-  const getUserRoles = async() => {
-    const user = await auth.getUser();
-    const appName = await application();
-
-    if (!user || !('applications' in user)) {
-      return [];
-    }
-
-    return user.applications.find(a => a.name === appName)?.roles || [];
-  };
-
-  const userHasRole = async(role: string[]) => {
-    const roles = await getUserRoles();
-
-    if (!roles.some(r => role.includes(r))) {
-      return false;
-    }
-
-    return true;
-  };
-
-  const assertUserRole = async(role: string[], fail: AssertionFailed = new UnauthorizedError()): Promise<void> => {
-    if (! await userHasRole(role)) {
-      return doThrow(fail);
-    }
-  };
-
-  return {
-    getUserRoles,
-    userHasRole,
-    assertUserRole
-  };
-};
-
-export type UserRoleValidator = ReturnType<typeof createUserRoleValidator>;

package/packages/utils/src/services/authProvider/utils/userSubrequest.spec.ts

@@ -1,26 +0,0 @@
-import { ApiUser } from '..';
-import { GenericFetch } from '../../../fetch';
-import { loadUserData } from './userSubrequest';
-
-describe('user subrequest', () => {
-  let fetchSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    fetchSpy = jest.fn();
-  });
-
-  const accountsBase = 'accountsBase';
-  const cookieName = 'sweet_cookie';
-  const cookie = 'yummy';
-
-  it('returns an ApiUser using a subrequest to Accounts', async() => {
-    const userResponse = {} as ApiUser;
-    fetchSpy.mockReturnValue(Promise.resolve({headers: {get: () => null}, json: () => userResponse}));
-    const user = await loadUserData(fetchSpy as unknown as GenericFetch, accountsBase, cookieName, cookie);
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    expect(fetchSpy).toHaveBeenCalledWith('accountsBase/api/user', {
-      headers: {cookie: `${cookieName}=${cookie}`},
-    });
-    expect(user).toBe(userResponse);
-  });
-});

package/packages/utils/src/services/authProvider/utils/userSubrequest.ts

@@ -1,10 +0,0 @@
-import cookie from 'cookie';
-import { ApiUser } from '..';
-import { GenericFetch } from '../../../fetch';
-
-export const loadUserData = (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => {
-  const headers = {cookie: cookie.serialize(cookieName, token)};
-
-  return fetch(accountsBase.replace(/\/+$/, '') + '/api/user', {headers})
-           .then(response => response.json() as Promise<ApiUser | undefined>);
-};

package/packages/utils/src/services/documentStore/dynamoEncoding.ts

@@ -1,57 +0,0 @@
-import { AttributeValue } from '@aws-sdk/client-dynamodb';
-import { isPlainObject } from '../../guards';
-import { DocumentBaseType, DocumentBaseValueTypes } from '.';
-
-export const encodeDynamoAttribute = (value: DocumentBaseValueTypes): AttributeValue => {
-  if (typeof value === 'string') {
-    return {S: value};
-  }
-  if (typeof value === 'number') {
-    return {N: value.toString()};
-  }
-  if (typeof value === 'boolean') {
-    return {BOOL: value};
-  }
-  if (value === null) {
-    return {NULL: true};
-  }
-  if (value instanceof Array) {
-    return {L: value.map(encodeDynamoAttribute)};
-  }
-  if (isPlainObject(value)) {
-    return {M: encodeDynamoDocument(value)};
-  }
-
-  throw new Error(`unknown attribute type ${typeof value} with value ${value}.`);
-};
-
-export const encodeDynamoDocument = (base: DocumentBaseType) => Object.fromEntries(Object.entries(base).map(
-  ([key, value]) => ([key, encodeDynamoAttribute(value)])
-));
-
-export const decodeDynamoAttribute = (value: AttributeValue): DocumentBaseValueTypes => {
-  if (value.S !== undefined) {
-    return value.S;
-  }
-  if (value.N !== undefined) {
-    return parseFloat(value.N);
-  }
-  if (value.BOOL !== undefined) {
-    return value.BOOL;
-  }
-  if (value.NULL !== undefined) {
-    return null;
-  }
-  if (value.L !== undefined) {
-    return value.L.map(decodeDynamoAttribute);
-  }
-  if (value.M !== undefined) {
-    return decodeDynamoDocument(value.M);
-  }
-
-  throw new Error(`unknown attribute type: ${JSON.stringify(value)}.`);
-};
-
-export const decodeDynamoDocument = <T extends DocumentBaseType>(document: {[key: string]: AttributeValue}): T => Object.fromEntries(Object.entries(document).map(
-  ([key, value]) => ([key, decodeDynamoAttribute(value)])
-)) as T;

package/packages/utils/src/services/documentStore/fileSystemAssert.spec.ts

@@ -1,43 +0,0 @@
-import { assertNoUndefined } from './fileSystemAssert';
-
-describe('assertNoUndefined', () => {
-
-  it('does not throw for defined primitive values', () => {
-    expect(() => assertNoUndefined('string')).not.toThrow();
-    expect(() => assertNoUndefined(42)).not.toThrow();
-    expect(() => assertNoUndefined(false)).not.toThrow();
-    expect(() => assertNoUndefined(null)).not.toThrow();
-  });
-
-  it('throws for undefined root value', () => {
-    expect(() => assertNoUndefined(undefined)).toThrow('unknown attribute type undefined');
-  });
-
-  it('does not throw for empty object', () => {
-    expect(() => assertNoUndefined({})).not.toThrow();
-  });
-
-  it('throws for undefined property in object', () => {
-    expect(() => assertNoUndefined({ foo: undefined })).toThrow('unknown attribute type undefined with value undefined at foo');
-  });
-
-  it('throws for nested undefined property', () => {
-    expect(() => assertNoUndefined({ a: { b: undefined } })).toThrow('unknown attribute type undefined with value undefined at a.b');
-  });
-
-  it('does not throw for object with only defined properties', () => {
-    expect(() => assertNoUndefined({ a: 1, b: 'ok', c: true })).not.toThrow();
-  });
-
-  it('throws for array with undefined element', () => {
-    expect(() => assertNoUndefined([1, undefined, 3])).toThrow('unknown attribute type undefined with value undefined at 1');
-  });
-
-  it('throws for deeply nested undefined in array', () => {
-    expect(() => assertNoUndefined({ arr: [1, { foo: undefined }] })).toThrow('unknown attribute type undefined with value undefined at arr.1.foo');
-  });
-
-  it('does not throw for array with only defined elements', () => {
-    expect(() => assertNoUndefined([1, 2, 3])).not.toThrow();
-  });
-});

package/packages/utils/src/services/documentStore/fileSystemAssert.ts

@@ -1,10 +0,0 @@
-export const assertNoUndefined = (obj: any, path: string[] = []) => {
-  if (obj === undefined) {
-    throw new Error(`unknown attribute type ${typeof obj} with value ${obj} at ${path.join('.') || 'root'}.`);
-  }
-  if (obj && typeof obj === 'object') {
-    for (const [key, value] of Object.entries(obj)) {
-      assertNoUndefined(value, [...path, key]);
-    }
-  }
-};

package/packages/utils/src/services/documentStore/unversioned/README.md

@@ -1,13 +0,0 @@
-# UnversionedDocumentStore
-
-a key value document store where documents can be updated. useful for caching.
-
-## drivers
-
-### dynamo
-
-production driver, the entity key is the hash key
-
-### fileSystem
-
-just matches the interface over dumping everything into one json file per key on disk