@pwrdrvr/microapps-datalib 0.0.18 → 0.0.22

package/src/index.ts

@@ -1,64 +1,6 @@
-import { DynamoDB } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { DBManager } from './manager';
+import { Application, IVersionsAndRules } from './models/application';
+import { Rules } from './models/rules';
+import { Version } from './models/version';
 
-import { Config } from './config';
-import Application from './models/application';
-import Rules from './models/rules';
-import Version from './models/version';
-
-export { Application, Version, Rules };
-
-export interface IVersionsAndRules {
-  Versions: Version[];
-  Rules: Rules;
-}
-
-export default class Manager {
-  public static async UpdateDefaultRule(appName: string, semVer: string): Promise<void> {
-    const rules = await Rules.LoadAsync(Manager._ddbDocClient, appName);
-
-    const defaultRule = rules.RuleSet.default;
-    defaultRule.SemVer = semVer;
-
-    await rules.SaveAsync(this._ddbDocClient);
-  }
-
-  public static async GetVersionsAndRules(appName: string): Promise<IVersionsAndRules> {
-    // Get all versions and rules for an app
-    // Note: versions are moved out of this key as they become inactive
-    // There should be less than, say, 100 versions per app
-
-    const versionTask = Version.LoadVersionsAsync(Manager._ddbDocClient, appName);
-    const rulesTask = Rules.LoadAsync(Manager._ddbDocClient, appName);
-
-    await Promise.all([versionTask, rulesTask]);
-
-    return {
-      Versions: await versionTask,
-      Rules: await rulesTask,
-    };
-  }
-
-  private static _client: DynamoDB;
-  private static _ddbDocClient: DynamoDBDocument;
-
-  public constructor(args: { dynamoDB: DynamoDB; tableName: string }) {
-    const { dynamoDB, tableName } = args;
-    if (Manager._client === undefined) {
-      Config.TableName = tableName;
-      Manager._client = dynamoDB;
-      Manager._ddbDocClient = DynamoDBDocument.from(Manager._client);
-    }
-  }
-
-  public static get TableName(): string {
-    return Config.TableName;
-  }
-
-  public static get DBClient(): DynamoDB {
-    return Manager._client;
-  }
-  public static get DBDocClient(): DynamoDBDocument {
-    return Manager._ddbDocClient;
-  }
-}
+export { Application, DBManager, Version, Rules, IVersionsAndRules };

package/src/manager.ts

@@ -0,0 +1,35 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+
+export interface IDBManager {
+  readonly client: DynamoDBClient;
+  readonly ddbDocClient: DynamoDBDocument;
+}
+
+export class DBManager implements IDBManager {
+  private _client: DynamoDBClient;
+  private _ddbDocClient: DynamoDBDocument;
+  private _tableName: string;
+
+  public get client(): DynamoDBClient {
+    return this._client;
+  }
+
+  public get ddbDocClient(): DynamoDBDocument {
+    return this._ddbDocClient;
+  }
+
+  public constructor(args: { dynamoClient: DynamoDBClient; tableName: string }) {
+    const { dynamoClient, tableName } = args;
+    this._tableName = tableName;
+    this._client = dynamoClient;
+    this._ddbDocClient = DynamoDBDocument.from(this._client);
+  }
+
+  public get tableName(): string {
+    return this._tableName;
+  }
+  public set tableName(value: string) {
+    this._tableName = value;
+  }
+}

package/src/models/application.spec.ts

@@ -1,51 +1,61 @@
-import { expect } from 'chai';
-import { describe, it } from 'mocha';
-import { dynamoClient, DropTable, InitializeTable, TEST_TABLE_NAME } from '../../../../fixtures';
-import Manager from '../index';
-import Application from './application';
+import 'jest-dynalite/withDb';
+import * as dynamodb from '@aws-sdk/client-dynamodb';
+import { DBManager } from '../manager';
+import { Application } from './application';
+import { Version } from './version';
+import { Rules } from './rules';
+
+let dynamoClient: dynamodb.DynamoDBClient;
+let dbManager: DBManager;
+
+const TEST_TABLE_NAME = 'microapps';
 
 describe('application records', () => {
-  before(async () => {
-    new Manager({ dynamoDB: dynamoClient.client, tableName: TEST_TABLE_NAME });
-  });
+  beforeAll(() => {
+    dynamoClient = new dynamodb.DynamoDBClient({
+      endpoint: process.env.MOCK_DYNAMODB_ENDPOINT,
+      tls: false,
+      region: 'local',
+    });
 
-  beforeEach(async () => {
-    // Create the table
-    await InitializeTable();
+    // Init the DB manager to point it at the right table
+    dbManager = new DBManager({ dynamoClient, tableName: TEST_TABLE_NAME });
   });
 
-  afterEach(async () => {
-    await DropTable();
-  });
+  afterAll(() => {
+    dynamoClient.destroy();
+  }, 20000);
 
   it('saving an application should create two records', async () => {
     const application = new Application();
     application.AppName = 'Cat';
     application.DisplayName = 'Dog';
 
-    await application.SaveAsync(dynamoClient.ddbDocClient);
+    await application.Save(dbManager);
 
     {
-      const { Item } = await dynamoClient.ddbDocClient.get({
-        TableName: Manager.TableName,
+      const { Item } = await dbManager.ddbDocClient.get({
+        TableName: TEST_TABLE_NAME,
         Key: { PK: 'appname#cat', SK: 'application' },
       });
-      expect(Item.PK).equal('appname#cat');
-      expect(Item.SK).equal('application');
-      expect(Item.AppName).equal('cat');
-      expect(Item.DisplayName).equal('Dog');
+      expect(Item).toBeDefined();
+      expect(Item?.PK).toBe('appname#cat');
+      expect(Item?.SK).toBe('application');
+      expect(Item?.AppName).toBe('cat');
+      expect(Item?.DisplayName).toBe('Dog');
     }
 
     {
-      const { Item } = await dynamoClient.ddbDocClient.get({
-        TableName: Manager.TableName,
+      const { Item } = await dbManager.ddbDocClient.get({
+        TableName: TEST_TABLE_NAME,
         Key: { PK: 'applications', SK: 'appname#cat' },
         // ProjectionExpression: 'PK,SK,AppName,DisplayName',
       });
-      expect(Item.PK).equal('applications');
-      expect(Item.SK).equal('appname#cat');
-      expect(Item.AppName).equal('cat');
-      expect(Item.DisplayName).equal('Dog');
+      expect(Item).toBeDefined();
+      expect(Item?.PK).toBe('applications');
+      expect(Item?.SK).toBe('appname#cat');
+      expect(Item?.AppName).toBe('cat');
+      expect(Item?.DisplayName).toBe('Dog');
     }
   });
 
@@ -53,64 +63,140 @@ describe('application records', () => {
     let application = new Application();
     application.AppName = 'App1';
     application.DisplayName = 'Application One';
-    await application.SaveAsync(dynamoClient.ddbDocClient);
+    await application.Save(dbManager);
 
     application = new Application();
     application.AppName = 'App2';
     application.DisplayName = 'Application Two';
-    await application.SaveAsync(dynamoClient.ddbDocClient);
+    await application.Save(dbManager);
 
     {
-      const record = await Application.LoadAsync(dynamoClient.ddbDocClient, 'App1');
+      const record = await Application.Load({ dbManager, key: { AppName: 'App1' } });
 
-      expect(record.PK).equal('appname#app1');
-      expect(record.SK).equal('application');
-      expect(record.AppName).equal('app1');
-      expect(record.DisplayName).equal('Application One');
+      expect(record.PK).toBe('appname#app1');
+      expect(record.SK).toBe('application');
+      expect(record.AppName).toBe('app1');
+      expect(record.DisplayName).toBe('Application One');
     }
 
     {
-      const record = await Application.LoadAsync(dynamoClient.ddbDocClient, 'App2');
+      const record = await Application.Load({ dbManager, key: { AppName: 'App2' } });
 
-      expect(record.PK).equal('appname#app2');
-      expect(record.SK).equal('application');
-      expect(record.AppName).equal('app2');
-      expect(record.DisplayName).equal('Application Two');
+      expect(record.PK).toBe('appname#app2');
+      expect(record.SK).toBe('application');
+      expect(record.AppName).toBe('app2');
+      expect(record.DisplayName).toBe('Application Two');
     }
   });
 
-  it('LoadAsync should handle missing records', async () => {
-    const record = await Application.LoadAsync(dynamoClient.ddbDocClient, 'App1');
-    expect(record).to.be.equal(undefined);
+  it('Load should handle missing records', async () => {
+    const record = await Application.Load({ dbManager, key: { AppName: 'App1' } });
+    expect(record).toBeUndefined();
   });
 
   it('LoadAllAppsAsync should return all applications', async () => {
     let application = new Application();
     application.AppName = 'Bpp1';
     application.DisplayName = 'Bpplication One';
-    await application.SaveAsync(dynamoClient.ddbDocClient);
+    await application.Save(dbManager);
 
     application = new Application();
     application.AppName = 'Bpp2';
     application.DisplayName = 'Bpplication Two';
-    await application.SaveAsync(dynamoClient.ddbDocClient);
+    await application.Save(dbManager);
 
-    const applications = await Application.LoadAllAppsAsync(dynamoClient.ddbDocClient);
-    expect(applications).to.exist;
+    const applications = await Application.LoadAllApps(dbManager);
+    expect(applications).toBeDefined();
     const appOne = applications.find((value) => {
       return value.AppName === 'bpp1';
     });
-    expect(appOne).to.exist;
-    expect(appOne).to.have.property('AppName');
-    expect(appOne.AppName).to.equal('bpp1');
-    expect(appOne.DisplayName).to.equal('Bpplication One');
+    expect(appOne).toBeDefined();
+    expect(appOne).toHaveProperty('AppName');
+    expect(appOne?.AppName).toBe('bpp1');
+    expect(appOne?.DisplayName).toBe('Bpplication One');
 
     const appTwo = applications.find((value) => {
       return value.AppName === 'bpp2';
     });
-    expect(appTwo).to.exist;
-    expect(appTwo).to.have.property('AppName');
-    expect(appTwo.AppName).to.equal('bpp2');
-    expect(appTwo.DisplayName).to.equal('Bpplication Two');
+    expect(appTwo).toBeDefined();
+    expect(appTwo).toHaveProperty('AppName');
+    expect(appTwo?.AppName).toBe('bpp2');
+    expect(appTwo?.DisplayName).toBe('Bpplication Two');
+  });
+
+  it('should get versions and rules when asked', async () => {
+    const app = new Application({
+      AppName: 'Bat',
+      DisplayName: 'Bat App',
+    });
+    await app.Save(dbManager);
+
+    const version = new Version({
+      AppName: 'Bat',
+      DefaultFile: 'bat.html',
+      IntegrationID: 'abcd',
+      SemVer: '3.2.1-beta0',
+      Status: 'deployed',
+      Type: 'next.js',
+    });
+    await version.Save(dbManager);
+
+    const rules = new Rules({
+      AppName: 'Bat',
+      Version: 0,
+      RuleSet: { default: { SemVer: '3.2.1-beta0', AttributeName: '', AttributeValue: '' } },
+    });
+    await rules.Save(dbManager);
+
+    const versAndRules = await Application.GetVersionsAndRules({
+      dbManager,
+      key: { AppName: 'bat' },
+    });
+
+    expect(versAndRules).toHaveProperty('Versions');
+    expect(versAndRules).toHaveProperty('Rules');
+    expect(versAndRules.Rules).toHaveProperty('RuleSet');
+    expect(versAndRules.Rules.RuleSet).toHaveProperty('default');
+    expect(versAndRules.Rules.RuleSet.default).toHaveProperty('SemVer');
+    expect(versAndRules.Rules.RuleSet.default.SemVer).toBe('3.2.1-beta0');
+    expect(versAndRules.Versions.length).toBe(1);
+    expect(versAndRules.Versions[0].SemVer).toBe('3.2.1-beta0');
+  });
+
+  it('should update default rule', async () => {
+    const app = new Application({
+      AppName: 'Bat2',
+      DisplayName: 'Bat App',
+    });
+    await app.Save(dbManager);
+
+    const version = new Version({
+      AppName: 'Bat2',
+      DefaultFile: 'bat.html',
+      IntegrationID: 'abcd',
+      SemVer: '3.2.1-beta0',
+      Status: 'deployed',
+      Type: 'next.js',
+    });
+    await version.Save(dbManager);
+
+    const rules = new Rules({
+      AppName: 'Bat2',
+      Version: 0,
+      RuleSet: { default: { SemVer: '3.2.1-beta0', AttributeName: '', AttributeValue: '' } },
+    });
+    await rules.Save(dbManager);
+
+    // Check version before update
+    let versAndRules = await Application.GetVersionsAndRules({
+      dbManager,
+      key: { AppName: 'bat2' },
+    });
+    expect(versAndRules.Rules.RuleSet.default.SemVer).toBe('3.2.1-beta0');
+
+    // Update default version
+    await Application.UpdateDefaultRule({ dbManager, key: { AppName: 'bat2', SemVer: '3.2.2' } });
+    versAndRules = await Application.GetVersionsAndRules({ dbManager, key: { AppName: 'bat2' } });
+    expect(versAndRules.Rules.RuleSet.default.SemVer).toBe('3.2.2');
   });
 });

package/src/models/application.ts

@@ -1,12 +1,18 @@
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
 import { plainToClass } from 'class-transformer';
-import { Config } from '../config';
+import { DBManager } from '../manager';
+import { Rules } from './rules';
+import { Version, IVersionRecord } from './version';
 
 enum SaveBy {
   AppName,
   Applications,
 }
 
+export interface IVersionsAndRules {
+  Versions: Version[];
+  Rules: Rules;
+}
+
 interface IApplicationRecord {
   PK: string;
   SK: string;
@@ -14,22 +20,59 @@ interface IApplicationRecord {
   DisplayName: string;
 }
 
-export default class Application implements IApplicationRecord {
-  public static async LoadAsync(
-    ddbDocClient: DynamoDBDocument,
-    appName: string,
-  ): Promise<Application> {
-    const { Item } = await ddbDocClient.get({
-      TableName: Config.TableName,
-      Key: { PK: `appName#${appName}`.toLowerCase(), SK: 'application' },
+export class Application implements IApplicationRecord {
+  public static async UpdateDefaultRule(opts: {
+    dbManager: DBManager;
+    key: Pick<IVersionRecord, 'AppName' | 'SemVer'>;
+  }): Promise<void> {
+    const { dbManager, key } = opts;
+
+    const rules = await Rules.Load({ dbManager, key });
+
+    const defaultRule = rules.RuleSet.default;
+    defaultRule.SemVer = key.SemVer;
+
+    await rules.Save(dbManager);
+  }
+
+  public static async GetVersionsAndRules(opts: {
+    dbManager: DBManager;
+    key: Pick<IApplicationRecord, 'AppName'>;
+  }): Promise<IVersionsAndRules> {
+    const { key, dbManager } = opts;
+
+    // Get all versions and rules for an app
+    // Note: versions are moved out of this key as they become inactive
+    // There should be less than, say, 100 versions per app
+
+    const versionTask = Version.LoadVersions({ dbManager, key });
+    const rulesTask = Rules.Load({ dbManager, key });
+
+    await Promise.all([versionTask, rulesTask]);
+
+    return {
+      Versions: await versionTask,
+      Rules: await rulesTask,
+    };
+  }
+
+  public static async Load(opts: {
+    dbManager: DBManager;
+    key: Pick<IApplicationRecord, 'AppName'>;
+  }): Promise<Application> {
+    const { key, dbManager } = opts;
+
+    const { Item } = await dbManager.ddbDocClient.get({
+      TableName: dbManager.tableName,
+      Key: { PK: `appName#${key.AppName}`.toLowerCase(), SK: 'application' },
     });
     const record = plainToClass<Application, unknown>(Application, Item);
     return record;
   }
 
-  public static async LoadAllAppsAsync(ddbDocClient: DynamoDBDocument): Promise<Application[]> {
-    const { Items } = await ddbDocClient.query({
-      TableName: Config.TableName,
+  public static async LoadAllApps(dbManager: DBManager): Promise<Application[]> {
+    const { Items } = await dbManager.ddbDocClient.query({
+      TableName: dbManager.tableName,
       KeyConditionExpression: 'PK = :pkval',
       ExpressionAttributeValues: {
         ':pkval': 'applications',
@@ -65,20 +108,20 @@ export default class Application implements IApplicationRecord {
     };
   }
 
-  public async SaveAsync(ddbDocClient: DynamoDBDocument): Promise<void> {
+  public async Save(dbManager: DBManager): Promise<void> {
     // TODO: Validate that all the fields needed are present
 
     // Save under specific AppName key
     this._keyBy = SaveBy.AppName;
-    const taskByName = ddbDocClient.put({
-      TableName: Config.TableName,
+    const taskByName = dbManager.ddbDocClient.put({
+      TableName: dbManager.tableName,
       Item: this.DbStruct,
     });
 
     // Save under all Applications key
     this._keyBy = SaveBy.Applications;
-    const taskByApplications = ddbDocClient.put({
-      TableName: Config.TableName,
+    const taskByApplications = dbManager.ddbDocClient.put({
+      TableName: dbManager.tableName,
       Item: this.DbStruct,
     });
 

package/src/models/rules.spec.ts

@@ -1,22 +1,28 @@
-import { expect } from 'chai';
-import { describe, it } from 'mocha';
-import { dynamoClient, InitializeTable, DropTable, TEST_TABLE_NAME } from '../../../../fixtures';
-import Manager from '../index';
-import Rules from './rules';
+import 'jest-dynalite/withDb';
+import * as dynamodb from '@aws-sdk/client-dynamodb';
+import { DBManager } from '../manager';
+import { Rules } from './rules';
+
+let dynamoClient: dynamodb.DynamoDBClient;
+let dbManager: DBManager;
+
+const TEST_TABLE_NAME = 'microapps';
 
 describe('rules records', () => {
-  before(async () => {
-    new Manager({ dynamoDB: dynamoClient.client, tableName: TEST_TABLE_NAME });
-  });
+  beforeAll(() => {
+    dynamoClient = new dynamodb.DynamoDBClient({
+      endpoint: process.env.MOCK_DYNAMODB_ENDPOINT,
+      tls: false,
+      region: 'local',
+    });
 
-  beforeEach(async () => {
-    // Create the table
-    await InitializeTable();
+    // Init the DB manager to point it at the right table
+    dbManager = new DBManager({ dynamoClient, tableName: TEST_TABLE_NAME });
   });
 
-  afterEach(async () => {
-    await DropTable();
-  });
+  afterAll(() => {
+    dynamoClient.destroy();
+  }, 20000);
 
   it('saving rules should create 1 record', async () => {
     const rules = new Rules();
@@ -24,19 +30,20 @@ describe('rules records', () => {
     rules.Version = 0;
     rules.RuleSet.default = { SemVer: '1.2.3', AttributeName: '', AttributeValue: '' };
 
-    await rules.SaveAsync(dynamoClient.ddbDocClient);
+    await rules.Save(dbManager);
 
     {
-      const record = await Rules.LoadAsync(dynamoClient.ddbDocClient, 'Cat');
-
-      expect(record.PK).equal('appname#cat');
-      expect(record.SK).equal('rules');
-      expect(record.AppName).equal('cat');
-      expect(record.Version).equal(0);
-      expect(record).to.have.property('RuleSet');
-      expect(record.RuleSet).to.have.property('default');
-      expect(record.RuleSet.default).to.have.property('SemVer');
-      expect(record.RuleSet.default.SemVer).to.equal('1.2.3');
+      const record = await Rules.Load({ dbManager, key: { AppName: 'Cat' } });
+
+      expect(record).toBeDefined();
+      expect(record.PK).toBe('appname#cat');
+      expect(record.SK).toBe('rules');
+      expect(record.AppName).toBe('cat');
+      expect(record.Version).toBe(0);
+      expect(record).toHaveProperty('RuleSet');
+      expect(record.RuleSet).toHaveProperty('default');
+      expect(record.RuleSet.default).toHaveProperty('SemVer');
+      expect(record.RuleSet.default.SemVer).toBe('1.2.3');
     }
   });
 });

package/src/models/rules.ts

@@ -1,6 +1,6 @@
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
 import { plainToClass } from 'class-transformer';
-import { Config } from '../config';
+import { DBManager } from '..';
+import { IVersionRecord } from './version';
 
 export interface IRule {
   SemVer: string;
@@ -18,11 +18,16 @@ export interface IRulesRecord {
   Version: number;
 }
 
-export default class Rules implements IRulesRecord {
-  public static async LoadAsync(ddbDocClient: DynamoDBDocument, appName: string): Promise<Rules> {
-    const { Item } = await ddbDocClient.get({
-      TableName: Config.TableName,
-      Key: { PK: `appName#${appName}`.toLowerCase(), SK: 'rules' },
+export class Rules implements IRulesRecord {
+  public static async Load(opts: {
+    dbManager: DBManager;
+    key: Pick<IVersionRecord, 'AppName'>;
+  }): Promise<Rules> {
+    const { dbManager, key } = opts;
+
+    const { Item } = await dbManager.ddbDocClient.get({
+      TableName: dbManager.tableName,
+      Key: { PK: `appName#${key.AppName}`.toLowerCase(), SK: 'rules' },
     });
     const record = plainToClass<Rules, unknown>(Rules, Item);
     return record;
@@ -49,18 +54,18 @@ export default class Rules implements IRulesRecord {
     };
   }
 
-  public async SaveAsync(ddbDocClient: DynamoDBDocument): Promise<void> {
+  public async Save(dbManager: DBManager): Promise<void> {
     // TODO: Validate that all the fields needed are present
 
     // Save under specific AppName key
-    const taskByName = ddbDocClient.put({
-      TableName: Config.TableName,
+    const taskByName = dbManager.ddbDocClient.put({
+      TableName: dbManager.tableName,
       Item: this.DbStruct,
     });
 
     // Save under all Applications key
-    const taskByApplications = ddbDocClient.put({
-      TableName: Config.TableName,
+    const taskByApplications = dbManager.ddbDocClient.put({
+      TableName: dbManager.tableName,
       Item: this.DbStruct,
     });