@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/services/lrsGateway/file-system.spec.ts

@@ -0,0 +1,363 @@
+import { TextEncoder } from 'util';
+import { UnauthorizedError } from '../../errors';
+import { stubAuthProvider, User } from '../authProvider';
+import { fileSystemLrsGateway } from './file-system';
+import { LrsGateway, XapiStatement } from '.';
+
+jest.mock('uuid', () => {
+  let count = 1;
+  const v4 = () => `random-uuid-${count++}`;
+  return {v4};
+});
+
+const payloadFields = (options?: {verb?: string; activity?: string; registration?: string; parent?: string}): Pick<XapiStatement, 'object' | 'verb' | 'context'> => ({
+  ...(options?.parent || options?.registration ? {
+    context: {
+      ...(options?.parent ? {
+        contextActivities: {
+          parent: [{id: options.parent, objectType: 'Activity' as const}]
+        },
+      } : {}),
+      ...(options?.registration ? {registration: options.registration} : {})
+    },
+  } : {}),
+  object: {
+    objectType: 'Activity' as const,
+    id: options?.activity || 'cool object'
+  },
+  verb: {id: options?.verb || 'cool verb'}
+});
+
+const savedFields = (index: number, userId: string = 'cool uuid') => ({
+  id: 'random-uuid-' + index,
+  actor: {
+    account: {
+      homePage: 'https://openstax.org', name: userId
+    },
+    objectType: 'Agent'
+  },
+  timestamp: '2020-02-01T00:00:00Z',
+  stored: '2020-02-01T00:00:00Z',
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+beforeEach(() => {
+  jest.useFakeTimers();
+  jest.setSystemTime(new Date(2020, 1, 1));
+});
+
+describe('lrsGateway', () => {
+  let user: undefined | {uuid: string};
+  const config = {
+    fileSystem: {
+      name: 'lrs'
+    }
+  };
+  let lrs: LrsGateway;
+  let readFileSpy: jest.SpyInstance;
+  let writeFileSpy: jest.SpyInstance;
+  let data: string | undefined;
+  let error: Error | null = null;
+  let fs: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
+
+  let consoleError: jest.SpyInstance;
+
+  beforeEach(() => {
+    error = null;
+    data = undefined;
+
+    consoleError = jest.spyOn(console, 'error').mockImplementation(() => null);
+
+    readFileSpy = jest.fn()
+      .mockImplementation((_file, cb) => cb(error, Buffer.from(new TextEncoder().encode(data).buffer)));
+    writeFileSpy = jest.fn()
+      .mockImplementation((_file, _data, cb) => cb(error));
+
+    fs = {readFile: readFileSpy, writeFile: writeFileSpy} as any;
+
+    user = undefined;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    consoleError.mockRestore();
+  });
+
+  it('loads data from file', async() => {
+    const authProvider = stubAuthProvider(user as User);
+    const middleware = {authProvider};
+    user = {uuid: 'cool uuid'};
+    lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+    await lrs.getXapiStatements({});
+    expect(readFileSpy).toHaveBeenCalledWith('file/path/to/lrs', expect.anything());
+  });
+
+  it('handles read error', async() => {
+    const authProvider = stubAuthProvider(user as User);
+    const middleware = {authProvider};
+    user = {uuid: 'cool uuid'};
+    error = new Error('foobar error');
+    data = 'invalid json';
+    expect(() =>
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware)
+    ).not.toThrow();
+    await lrs.getXapiStatements({});
+    expect(readFileSpy).toHaveBeenCalledWith('file/path/to/lrs', expect.anything());
+  });
+
+  it('works with invalid json', async() => {
+    const authProvider = stubAuthProvider(user as User);
+    const middleware = {authProvider};
+    user = {uuid: 'cool uuid'};
+    data = '{}';
+    lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+    await lrs.getXapiStatements({});
+    expect(readFileSpy).toHaveBeenCalledWith('file/path/to/lrs', expect.anything());
+  });
+
+  describe('putXapiStatements', () => {
+    it('throws without a user', async() => {
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      await expect(lrs.putXapiStatements([])).rejects.toThrow(UnauthorizedError);
+      expect(writeFileSpy).not.toHaveBeenCalled();
+    });
+
+    it('submits statements', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const payload = payloadFields();
+      await lrs.putXapiStatements([payload]);
+
+      const testData = JSON.stringify([{
+        ...payload,
+        ...savedFields(1)
+      }], null, 2);
+      expect(writeFileSpy).toHaveBeenCalledWith('file/path/to/lrs', testData, expect.anything());
+    });
+  });
+
+  describe('getAllXapiStatements', () => {
+    it('throws without a user', async() => {
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      await expect(lrs.getAllXapiStatements({})).rejects.toThrow(UnauthorizedError);
+    });
+
+    it('submits statement query', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({});
+      expect(result).toEqual([]);
+    });
+
+    it('filters current actor', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1)},
+        {...payloadFields(), ...savedFields(2, 'other uuid')},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({});
+      expect(result).toEqual([
+        {...payloadFields(), ...savedFields(1)},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+    });
+
+    it('filters verb', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1)},
+        {...payloadFields({verb: 'other verb'}), ...savedFields(2)},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({verb: 'other verb'});
+      expect(result).toEqual([
+        {...payloadFields({verb: 'other verb'}), ...savedFields(2)},
+      ]);
+    });
+
+    it('filters registration', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1)},
+        {...payloadFields({registration: 'some uuid'}), ...savedFields(2)},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({registration: 'some uuid'});
+      expect(result).toEqual([
+        {...payloadFields({registration: 'some uuid'}), ...savedFields(2)},
+      ]);
+    });
+
+    it('filters narrow activity', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields({parent: 'this activity'}), ...savedFields(1)},
+        {...payloadFields({activity: 'this activity'}), ...savedFields(2)},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({activity: 'this activity'});
+      expect(result).toEqual([
+        {...payloadFields({activity: 'this activity'}), ...savedFields(2)},
+      ]);
+    });
+
+    it('filters related activity', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields({parent: 'this activity'}), ...savedFields(1)},
+        {...payloadFields({activity: 'this activity'}), ...savedFields(2)},
+        {...payloadFields(), ...savedFields(3)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({activity: 'this activity', related_activities: true});
+      expect(result).toEqual([
+        {...payloadFields({parent: 'this activity'}), ...savedFields(1)},
+        {...payloadFields({activity: 'this activity'}), ...savedFields(2)},
+      ]);
+    });
+
+    it('filters since', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1), timestamp: '2022-01-01T00:00:00Z'},
+        {...payloadFields(), ...savedFields(2), timestamp: '2022-01-02T00:00:00Z'},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({since: '2022-01-01T12:00:00Z'});
+      expect(result).toEqual([
+        {...payloadFields(), ...savedFields(2), timestamp: '2022-01-02T00:00:00Z'},
+      ]);
+    });
+
+    it('filters until', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1), timestamp: '2022-01-01T00:00:00Z'},
+        {...payloadFields(), ...savedFields(2), timestamp: '2022-01-02T00:00:00Z'},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getAllXapiStatements({until: '2022-01-01T12:00:00Z'});
+      expect(result).toEqual([
+        {...payloadFields(), ...savedFields(1), timestamp: '2022-01-01T00:00:00Z'},
+      ]);
+    });
+
+    describe('fetchUntil', () => {
+      it('returns the pages of statements that match the predicate', async () => {
+        user = { uuid: 'cool uuid' };
+        const authProvider = stubAuthProvider(user as User);
+        const middleware = {authProvider};
+        data = JSON.stringify([
+          { ...payloadFields({ activity: '1' }), ...savedFields(1) },
+          { ...payloadFields({ activity: '2' }), ...savedFields(2) },
+          { ...payloadFields({ activity: '3' }), ...savedFields(3) },
+          { ...payloadFields({ activity: '4' }), ...savedFields(4) },
+          { ...payloadFields({ activity: '5' }), ...savedFields(5) },
+          { ...payloadFields({ activity: '6' }), ...savedFields(6) },
+          { ...payloadFields({ activity: '7' }), ...savedFields(7) },
+        ]);
+        lrs = fileSystemLrsGateway({ fs, dataDir: 'file/path/to' })(config)(middleware);
+        const result = await lrs.getAllXapiStatements({
+          fetchUntil: (statements) => statements.some(s => s.object.id === '2')
+        });
+        expect(result).toEqual([
+          { ...payloadFields({ activity: '1' }), ...savedFields(1) },
+          { ...payloadFields({ activity: '2' }), ...savedFields(2) },
+          { ...payloadFields({ activity: '3' }), ...savedFields(3) },
+          { ...payloadFields({ activity: '4' }), ...savedFields(4) },
+          { ...payloadFields({ activity: '5' }), ...savedFields(5) },
+        ]);
+      });
+
+      it('returns all statements when there is no match', async () => {
+        user = { uuid: 'cool uuid' };
+        const authProvider = stubAuthProvider(user as User);
+        const middleware = {authProvider};
+        data = JSON.stringify([
+          { ...payloadFields({ activity: '1' }), ...savedFields(1) },
+          { ...payloadFields({ activity: '2' }), ...savedFields(2) },
+          { ...payloadFields({ activity: '3' }), ...savedFields(3) },
+          { ...payloadFields({ activity: '4' }), ...savedFields(4) },
+          { ...payloadFields({ activity: '5' }), ...savedFields(5) },
+          { ...payloadFields({ activity: '6' }), ...savedFields(6) },
+        ]);
+        lrs = fileSystemLrsGateway({ fs, dataDir: 'file/path/to' })(config)(middleware);
+        const result = await lrs.getAllXapiStatements({
+          fetchUntil: (statements) => statements.some(s => s.object.id === '0' )
+        });
+        expect(result).toEqual([
+          { ...payloadFields({ activity: '1' }), ...savedFields(1) },
+          { ...payloadFields({ activity: '2' }), ...savedFields(2) },
+          { ...payloadFields({ activity: '3' }), ...savedFields(3) },
+          { ...payloadFields({ activity: '4' }), ...savedFields(4) },
+          { ...payloadFields({ activity: '5' }), ...savedFields(5) },
+          { ...payloadFields({ activity: '6' }), ...savedFields(6) },
+        ]);
+      });
+    });
+  });
+
+  describe('pagination', () => {
+    it('paginates', async() => {
+      user = {uuid: 'cool uuid'};
+      const authProvider = stubAuthProvider(user as User);
+      const middleware = {authProvider};
+      data = JSON.stringify([
+        {...payloadFields(), ...savedFields(1)},
+        {...payloadFields(), ...savedFields(2)},
+        {...payloadFields(), ...savedFields(3)},
+        {...payloadFields(), ...savedFields(4)},
+        {...payloadFields(), ...savedFields(5)},
+        {...payloadFields(), ...savedFields(6)},
+        {...payloadFields(), ...savedFields(7)},
+        {...payloadFields(), ...savedFields(8)},
+        {...payloadFields(), ...savedFields(9)},
+        {...payloadFields(), ...savedFields(10)},
+        {...payloadFields(), ...savedFields(11)},
+      ]);
+      lrs = fileSystemLrsGateway({fs, dataDir: 'file/path/to'})(config)(middleware);
+      const result = await lrs.getXapiStatements({});
+      expect(result.statements).toHaveLength(5);
+
+      const moreResults = await lrs.getMoreXapiStatements(result.more);
+      expect(moreResults.statements).toHaveLength(5);
+
+      const moreMoreResults = await lrs.getMoreXapiStatements(moreResults.more);
+      expect(moreMoreResults.more).toBe('');
+      expect(moreMoreResults.statements).toHaveLength(1);
+    });
+  });
+});

package/packages/utils/src/services/lrsGateway/file-system.ts

@@ -0,0 +1,165 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import formatISO from 'date-fns/formatISO';
+import {v4 as uuid} from 'uuid';
+import { assertDefined } from '../../assertions';
+import { ConfigProviderForConfig, resolveConfigValue } from '../../config';
+import { UnauthorizedError } from '../../errors';
+import { ifDefined } from '../../guards';
+import { AuthProvider } from '../authProvider';
+import { EagerXapiStatement, LrsGateway, SavedXapiStatement, XapiStatement } from '.';
+
+type Config = {
+  name: string;
+};
+interface Initializer<C> {
+  dataDir: string;
+  fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
+  configSpace?: C;
+}
+
+const pageSize = 5;
+
+export const fileSystemLrsGateway = <C extends string = 'fileSystem'>(initializer: Initializer<C>) => (configProvider: {[_key in C]: ConfigProviderForConfig<Config>}) => ({authProvider}: {authProvider: AuthProvider}): LrsGateway => {
+  const name = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem' as C].name);
+  const filePath = name.then((fileName) => path.join(initializer.dataDir, fileName));
+  const {readFile, writeFile} = ifDefined(initializer.fs, fsModule);
+
+  let data: SavedXapiStatement[] | undefined;
+
+  const load = filePath.then(path =>
+    new Promise<void>(resolve => {
+      readFile(path, (err, readData) => {
+
+        if (err) {
+          console.error(err);
+        } else {
+          try {
+            data = JSON.parse(readData.toString());
+            if (typeof data !== 'object' || !(data instanceof Array)) {
+              data = undefined;
+            }
+          } catch (e) {
+            console.error(e);
+          }
+        }
+
+        resolve();
+      });
+    })
+  );
+
+  let previousSave: Promise<void>;
+
+  const putXapiStatements = async(
+    statements: Array<Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+      id?: string;
+    }>
+  ): Promise<EagerXapiStatement[]> => {
+    const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
+
+    const statementsWithDefaults: EagerXapiStatement[] = statements.map(statement => ({
+      ...statement,
+      id: uuid(),
+      actor: {
+        account: {
+          homePage: 'https://openstax.org',
+          name: user.uuid,
+        },
+        objectType: 'Agent',
+      },
+      timestamp: formatISO(new Date()),
+    }));
+
+    await load;
+    await previousSave;
+
+    const path = await filePath;
+    const save = previousSave = new Promise(resolve => {
+      data = data || [];
+      data.push(...statementsWithDefaults.map(statement => ({...statement, stored: statement.timestamp})));
+      writeFile(path, JSON.stringify(data, null, 2), () => resolve());
+    });
+
+    await save;
+
+    return statementsWithDefaults;
+  };
+
+  const getAllXapiStatements = async(
+    {user, anyUser, fetchUntil, ...options}: {
+      verb?: string;
+      activity?: string;
+      registration?: string;
+      related_activities?: boolean;
+      ensureSync?: boolean;
+      user?: string;
+      anyUser?: boolean;
+      fetchUntil?: (statements: XapiStatement[]) => boolean;
+      since?: string;
+      until?: string;
+    }
+  ) => {
+    const authUser = await authProvider.getUser();
+    await load;
+
+    let filteredData = (data || []).filter(statement => {
+      const statementDate = new Date(statement.timestamp);
+      const sinceDate = options.since ? new Date(options.since) : null;
+      const untilDate = options.until ? new Date(options.until) : null;
+
+      return (anyUser === true || statement.actor.account.name === (user || assertDefined(authUser, new UnauthorizedError()).uuid))
+        && (!options.verb || statement.verb.id === options.verb)
+        && (!options.registration || statement.context?.registration === options.registration)
+        && (!options.activity || (
+          options.related_activities
+            ? ((statement.object.id === options.activity && statement.object.objectType === 'Activity')
+              || (
+                !!statement.context?.contextActivities?.parent?.find(parent => parent.id === options.activity && parent.objectType === 'Activity')
+              )
+            )
+            : (statement.object.id === options.activity && statement.object.objectType === 'Activity')
+        ))
+        && (!sinceDate || statementDate >= sinceDate)
+        && (!untilDate || statementDate <= untilDate);
+    });
+
+    if (fetchUntil) {
+      for (let i = 0; i < filteredData.length; i += pageSize) {
+        if (fetchUntil(filteredData.slice(0, i + pageSize))) {
+          filteredData = filteredData.slice(0, i + pageSize);
+          break;
+        }
+      }
+    }
+
+    return filteredData;
+  };
+
+  const getMoreXapiStatements = async(more: string) => {
+    const {args, offset} = JSON.parse(more);
+    const allResults = await getAllXapiStatements(...(args as Parameters<typeof getAllXapiStatements>));
+    const end = offset + pageSize;
+
+    return {
+      more: allResults.length > end ? JSON.stringify({args, offset: end}) : '',
+      statements: allResults.slice(offset, end)
+    };
+  };
+
+  const getXapiStatements = async(...args: Parameters<typeof getAllXapiStatements>) => {
+    const allResults = await getAllXapiStatements(...args);
+
+    return {
+      more: allResults.length > pageSize ? JSON.stringify({args, offset: pageSize}) : '',
+      statements: allResults.slice(0, pageSize)
+    };
+  };
+
+  return {
+    putXapiStatements,
+    getAllXapiStatements,
+    getXapiStatements,
+    getMoreXapiStatements,
+  };
+};