@pwrdrvr/microapps-datalib 0.0.15 → 0.0.19

package/src/models/version.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 Version from './version';
+import 'jest-dynalite/withDb';
+import * as dynamodb from '@aws-sdk/client-dynamodb';
+import { DBManager } from '../manager';
+import { Version } from './version';
+
+let dynamoClient: dynamodb.DynamoDBClient;
+let dbManager: DBManager;
+
+const TEST_TABLE_NAME = 'microapps';
 
 describe('version 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 a version should create one record', async () => {
     const version = new Version();
@@ -27,20 +33,21 @@ describe('version records', () => {
     version.DefaultFile = 'index.html';
     version.IntegrationID = 'abcd';
 
-    await version.SaveAsync(dynamoClient.ddbDocClient);
+    await version.Save(dbManager);
 
-    const { Item } = await dynamoClient.ddbDocClient.get({
-      TableName: Manager.TableName,
+    const { Item } = await dbManager.ddbDocClient.get({
+      TableName: dbManager.tableName,
       Key: { PK: 'appname#cat', SK: 'version#1.2.3-beta4' },
     });
-    expect(Item.PK).equal('appname#cat');
-    expect(Item.SK).equal('version#1.2.3-beta4');
-    expect(Item.AppName).equal('cat');
-    expect(Item.SemVer).equal('1.2.3-Beta4');
-    expect(Item.Status).equal('pending');
-    expect(Item.Type).equal('type');
-    expect(Item.DefaultFile).equal('index.html');
-    expect(Item.IntegrationID).equal('abcd');
+    expect(Item).toBeDefined();
+    expect(Item?.PK).toBe('appname#cat');
+    expect(Item?.SK).toBe('version#1.2.3-beta4');
+    expect(Item?.AppName).toBe('cat');
+    expect(Item?.SemVer).toBe('1.2.3-Beta4');
+    expect(Item?.Status).toBe('pending');
+    expect(Item?.Type).toBe('type');
+    expect(Item?.DefaultFile).toBe('index.html');
+    expect(Item?.IntegrationID).toBe('abcd');
   });
 
   it('load 1 version should load 1 version', async () => {
@@ -52,7 +59,7 @@ describe('version records', () => {
     version.DefaultFile = 'index.html';
     version.IntegrationID = 'abcd';
 
-    await version.SaveAsync(dynamoClient.ddbDocClient);
+    await version.Save(dbManager);
 
     version = new Version();
     version.AppName = 'Dog';
@@ -62,27 +69,28 @@ describe('version records', () => {
     version.DefaultFile = 'index.html';
     version.IntegrationID = 'abcd';
 
-    await version.SaveAsync(dynamoClient.ddbDocClient);
+    await version.Save(dbManager);
 
-    const version1 = await Version.LoadVersionAsync(
-      dynamoClient.ddbDocClient,
-      'Dog',
-      '1.2.3-Beta5',
-    );
+    const version1 = await Version.LoadVersion({
+      dbManager,
+      key: {
+        AppName: 'Dog',
+        SemVer: '1.2.3-Beta5',
+      },
+    });
 
-    expect(version1.AppName).to.equal('dog');
-    expect(version1.SK).to.equal('version#1.2.3-beta5');
-    expect(version1.SemVer).to.equal('1.2.3-Beta5');
+    expect(version1.AppName).toBe('dog');
+    expect(version1.SK).toBe('version#1.2.3-beta5');
+    expect(version1.SemVer).toBe('1.2.3-Beta5');
 
-    const version2 = await Version.LoadVersionAsync(
-      dynamoClient.ddbDocClient,
-      'Dog',
-      '1.2.3-Beta6',
-    );
+    const version2 = await Version.LoadVersion({
+      dbManager,
+      key: { AppName: 'Dog', SemVer: '1.2.3-Beta6' },
+    });
 
-    expect(version2.AppName).to.equal('dog');
-    expect(version2.SK).to.equal('version#1.2.3-beta6');
-    expect(version2.SemVer).to.equal('1.2.3-Beta6');
+    expect(version2.AppName).toBe('dog');
+    expect(version2.SK).toBe('version#1.2.3-beta6');
+    expect(version2.SemVer).toBe('1.2.3-Beta6');
   });
 
   it('load all app versions should load all versions for 1 app', async () => {
@@ -94,7 +102,7 @@ describe('version records', () => {
     version.DefaultFile = 'index.html';
     version.IntegrationID = 'abcd';
 
-    await version.SaveAsync(dynamoClient.ddbDocClient);
+    await version.Save(dbManager);
 
     version = new Version();
     version.AppName = 'Frog';
@@ -104,17 +112,17 @@ describe('version records', () => {
     version.DefaultFile = 'index.html';
     version.IntegrationID = 'abcd';
 
-    await version.SaveAsync(dynamoClient.ddbDocClient);
+    await version.Save(dbManager);
 
-    const versions = await Version.LoadVersionsAsync(dynamoClient.ddbDocClient, 'Frog');
+    const versions = await Version.LoadVersions({ dbManager, key: { AppName: 'Frog' } });
 
-    expect(versions.length).to.equal(2);
+    expect(versions.length).toBe(2);
 
-    expect(versions[0].AppName).to.equal('frog');
-    expect(versions[0].SK).to.equal('version#2.2.3-beta5');
-    expect(versions[0].SemVer).to.equal('2.2.3-Beta5');
-    expect(versions[1].AppName).to.equal('frog');
-    expect(versions[1].SK).to.equal('version#2.2.3-beta6');
-    expect(versions[1].SemVer).to.equal('2.2.3-Beta6');
+    expect(versions[0].AppName).toBe('frog');
+    expect(versions[0].SK).toBe('version#2.2.3-beta5');
+    expect(versions[0].SemVer).toBe('2.2.3-Beta5');
+    expect(versions[1].AppName).toBe('frog');
+    expect(versions[1].SK).toBe('version#2.2.3-beta6');
+    expect(versions[1].SemVer).toBe('2.2.3-Beta6');
   });
 });

package/src/models/version.ts

@@ -1,6 +1,5 @@
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
 import { plainToClass } from 'class-transformer';
-import { Config } from '../config';
+import { DBManager } from '..';
 
 enum SaveBy {
   AppName,
@@ -25,16 +24,23 @@ export interface IVersionRecord {
   IntegrationID: string;
 }
 
-export default class Version implements IVersionRecord {
-  public static async LoadVersionsAsync(
-    ddbDocClient: DynamoDBDocument,
-    appName: string,
-  ): Promise<Version[]> {
-    const { Items } = await ddbDocClient.query({
-      TableName: Config.TableName,
+export type IVersionRecordNoKeysLoose = Partial<
+  Omit<IVersionRecord, 'PK' | 'SK' | 'AppName' | 'SemVer'>
+> &
+  Pick<IVersionRecord, 'AppName' | 'SemVer'>;
+
+export class Version implements IVersionRecord {
+  public static async LoadVersions(opts: {
+    dbManager: DBManager;
+    key: Pick<IVersionRecord, 'AppName'>;
+  }): Promise<Version[]> {
+    const { dbManager, key } = opts;
+
+    const { Items } = await dbManager.ddbDocClient.query({
+      TableName: dbManager.tableName,
       KeyConditionExpression: 'PK = :pkval and begins_with(SK, :skval)',
       ExpressionAttributeValues: {
-        ':pkval': `appName#${appName}`.toLowerCase(),
+        ':pkval': `appName#${key.AppName}`.toLowerCase(),
         ':skval': 'version',
       },
     });
@@ -49,16 +55,17 @@ export default class Version implements IVersionRecord {
     return records;
   }
 
-  public static async LoadVersionAsync(
-    ddbDocClient: DynamoDBDocument,
-    appName: string,
-    semVer: string,
-  ): Promise<Version> {
-    const { Item } = await ddbDocClient.get({
-      TableName: Config.TableName,
+  public static async LoadVersion(opts: {
+    dbManager: DBManager;
+    key: Pick<IVersionRecord, 'AppName' | 'SemVer'>;
+  }): Promise<Version> {
+    const { dbManager, key } = opts;
+
+    const { Item } = await dbManager.ddbDocClient.get({
+      TableName: dbManager.tableName,
       Key: {
-        PK: `appName#${appName}`.toLowerCase(),
-        SK: `version#${semVer}`.toLowerCase(),
+        PK: `appName#${key.AppName}`.toLowerCase(),
+        SK: `version#${key.SemVer}`.toLowerCase(),
       },
     });
     const record = plainToClass<Version, unknown>(Version, Item);
@@ -78,13 +85,18 @@ export default class Version implements IVersionRecord {
   private _appName: string | undefined;
   private _semVer: string | undefined;
   private _type: string | undefined;
-  private _status: VersionStatus | undefined;
-  private _defaultFile: string | undefined;
-  private _integrationID: string | undefined;
+  private _status: VersionStatus;
+  private _defaultFile: string;
+  private _integrationID: string;
 
-  public constructor(init?: Partial<IVersionRecord>) {
-    Object.assign(this, init);
+  public constructor(init?: Partial<IVersionRecordNoKeysLoose>) {
     this._keyBy = SaveBy.AppName;
+    this._status = 'pending';
+    this._defaultFile = '';
+    this._integrationID = '';
+
+    // Save any passed in values over the defaults
+    Object.assign(this, init);
   }
 
   public get DbStruct(): IVersionRecord {
@@ -100,13 +112,13 @@ export default class Version implements IVersionRecord {
     };
   }
 
-  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;
-    await ddbDocClient.put({
-      TableName: Config.TableName,
+    await dbManager.ddbDocClient.put({
+      TableName: dbManager.tableName,
       Item: this.DbStruct,
     });
   }

package/src/index.spec.ts

@@ -1,89 +0,0 @@
-import { expect } from 'chai';
-import { describe, it } from 'mocha';
-import { dynamoClient, InitializeTable, DropTable, TEST_TABLE_NAME } from '../../../fixtures';
-import Manager, { Application, Version, Rules } from './index';
-
-describe('database manager', () => {
-  before(async () => {
-    new Manager({ dynamoDB: dynamoClient.client, tableName: TEST_TABLE_NAME });
-  });
-
-  beforeEach(async () => {
-    // Create the table
-    await InitializeTable();
-  });
-
-  afterEach(async () => {
-    await DropTable();
-  });
-
-  it('should get versions and rules when asked', async () => {
-    const app = new Application({
-      AppName: 'Bat',
-      DisplayName: 'Bat App',
-    });
-    await app.SaveAsync(dynamoClient.ddbDocClient);
-
-    const version = new Version({
-      AppName: 'Bat',
-      DefaultFile: 'bat.html',
-      IntegrationID: 'abcd',
-      SemVer: '3.2.1-beta0',
-      Status: 'deployed',
-      Type: 'next.js',
-    });
-    await version.SaveAsync(dynamoClient.ddbDocClient);
-
-    const rules = new Rules({
-      AppName: 'Bat',
-      Version: 0,
-      RuleSet: { default: { SemVer: '3.2.1-beta0', AttributeName: '', AttributeValue: '' } },
-    });
-    await rules.SaveAsync(dynamoClient.ddbDocClient);
-
-    const versAndRules = await Manager.GetVersionsAndRules('bat');
-
-    expect(versAndRules).to.have.property('Versions');
-    expect(versAndRules).to.have.property('Rules');
-    expect(versAndRules.Rules).to.have.property('RuleSet');
-    expect(versAndRules.Rules.RuleSet).to.have.property('default');
-    expect(versAndRules.Rules.RuleSet.default).to.have.property('SemVer');
-    expect(versAndRules.Rules.RuleSet.default.SemVer).to.equal('3.2.1-beta0');
-    expect(versAndRules.Versions.length).to.equal(1);
-    expect(versAndRules.Versions[0].SemVer).to.equal('3.2.1-beta0');
-  });
-
-  it('should update default rule', async () => {
-    const app = new Application({
-      AppName: 'Bat2',
-      DisplayName: 'Bat App',
-    });
-    await app.SaveAsync(dynamoClient.ddbDocClient);
-
-    const version = new Version({
-      AppName: 'Bat2',
-      DefaultFile: 'bat.html',
-      IntegrationID: 'abcd',
-      SemVer: '3.2.1-beta0',
-      Status: 'deployed',
-      Type: 'next.js',
-    });
-    await version.SaveAsync(dynamoClient.ddbDocClient);
-
-    const rules = new Rules({
-      AppName: 'Bat2',
-      Version: 0,
-      RuleSet: { default: { SemVer: '3.2.1-beta0', AttributeName: '', AttributeValue: '' } },
-    });
-    await rules.SaveAsync(dynamoClient.ddbDocClient);
-
-    // Check version before update
-    let versAndRules = await Manager.GetVersionsAndRules('bat2');
-    expect(versAndRules.Rules.RuleSet.default.SemVer).to.equal('3.2.1-beta0');
-
-    // Update default version
-    await Manager.UpdateDefaultRule('bat2', '3.2.2');
-    versAndRules = await Manager.GetVersionsAndRules('bat2');
-    expect(versAndRules.Rules.RuleSet.default.SemVer).to.equal('3.2.2');
-  });
-});