@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,10 @@
+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/{dist/cjs/services/documentStore/index.d.ts → packages/utils/src/services/documentStore/index.ts}

@@ -1,14 +1,14 @@
 export type Config = {
-    tableName: string;
-};
-export type DocumentBaseMapType = {
-    [key: string]: DocumentBaseValueTypes;
+  tableName: string;
 };
+
+export type DocumentBaseMapType = {[key: string]: DocumentBaseValueTypes};
 export type DocumentBaseListType = DocumentBaseValueTypes[];
+
 export type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
-export type DocumentBaseType = {
-    [key: string]: DocumentBaseValueTypes;
-};
+
+export type DocumentBaseType = {[key: string]: DocumentBaseValueTypes};
+
 export type TDocument<T> = {
-    [_key in keyof T]: DocumentBaseValueTypes;
+  [_key in keyof T]: DocumentBaseValueTypes;
 };

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

@@ -0,0 +1,13 @@
+# 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