@bitblit/ratchet-aws 6.0.146-alpha → 6.0.147-alpha

package/src/route53/route-53-ratchet.ts

@@ -0,0 +1,77 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import {
+  ChangeResourceRecordSetsCommand,
+  ChangeResourceRecordSetsCommandInput,
+  ChangeResourceRecordSetsCommandOutput,
+  GetChangeCommandInput,
+  Route53Client,
+  waitUntilResourceRecordSetsChanged,
+} from '@aws-sdk/client-route-53';
+import { WaiterResult, WaiterState } from '@smithy/util-waiter';
+
+export class Route53Ratchet {
+  constructor(
+    private route53: Route53Client,
+    private hostedZoneId: string,
+  ) {
+    if (!this.route53) {
+      throw 'route53 may not be null';
+    }
+  }
+
+  public get route53Client(): Route53Client {
+    return this.route53;
+  }
+
+  public async changeCnameRecordTarget(
+    domainName: string,
+    target: string,
+    hostedZoneId: string = this.hostedZoneId,
+    ttlSeconds = 600,
+  ): Promise<boolean> {
+    Logger.info('Updating %s to point to %s', domainName, target);
+
+    try {
+      const params: ChangeResourceRecordSetsCommandInput = {
+        ChangeBatch: {
+          Changes: [
+            {
+              Action: 'UPSERT',
+              ResourceRecordSet: {
+                Name: domainName,
+                ResourceRecords: [
+                  {
+                    Value: target,
+                  },
+                ],
+                TTL: ttlSeconds,
+                Type: 'CNAME',
+              },
+            },
+          ],
+        },
+        HostedZoneId: hostedZoneId,
+      };
+
+      const result: ChangeResourceRecordSetsCommandOutput = await this.route53.send(new ChangeResourceRecordSetsCommand(params));
+      Logger.debug('Updated domain result: %j', result);
+
+      const waitParams: GetChangeCommandInput = {
+        Id: result.ChangeInfo.Id,
+      };
+
+      const waitResult: WaiterResult = await waitUntilResourceRecordSetsChanged({ client: this.route53, maxWaitTime: 300 }, waitParams);
+      Logger.debug('Wait responsed: %j', waitResult);
+
+      if (waitResult.state === WaiterState.SUCCESS) {
+        Logger.info('Updated %s to point to %s', domainName, hostedZoneId);
+        return true;
+      }
+    } catch (err) {
+      Logger.warn('Error update CName for %s with value %s: %j', domainName, target, err);
+    }
+
+    Logger.info('Cannot update %s to point to %s', domainName, target);
+    return false;
+  }
+}

package/src/runtime-parameter/cached-stored-runtime-parameter.ts

@@ -0,0 +1,5 @@
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+
+export interface CachedStoredRuntimeParameter extends StoredRuntimeParameter {
+  storedEpochMS: number;
+}

package/src/runtime-parameter/global-variable-override-runtime-parameter-provider.spec.ts

@@ -0,0 +1,41 @@
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { GlobalVariableOverrideRuntimeParameterProvider } from './global-variable-override-runtime-parameter-provider.js';
+import { describe, expect, test } from 'vitest';
+import { MemoryRuntimeParameterProvider } from './memory-runtime-parameter-provider.js';
+
+const testEntry: StoredRuntimeParameter = { groupId: 'test', paramKey: 'test', paramValue: '15', ttlSeconds: 0.5 };
+const testEntry2: StoredRuntimeParameter = { groupId: 'test', paramKey: 'test1', paramValue: '"not-overridden"', ttlSeconds: 0.5 };
+
+describe('#globalVariableOverrideRuntimeParameterProvider', function () {
+  test('reads underlying entries', async () => {
+    Logger.setLevel(LoggerLevelName.silly);
+    //mockDynamoRatchet.fullyExecuteQuery.resolves([testEntry, testEntry2]);
+    const drpp: MemoryRuntimeParameterProvider = new MemoryRuntimeParameterProvider();
+    await drpp.writeParameter(testEntry);
+    await drpp.writeParameter(testEntry2);
+    const er: GlobalVariableOverrideRuntimeParameterProvider = new GlobalVariableOverrideRuntimeParameterProvider(drpp, {
+      globalTTL: 1,
+      separator: '.',
+      prefix: 'p-',
+      suffix: null,
+    });
+
+    process.env[er.generateName('test', 'test1')] = '"override"';
+    const rpr: RuntimeParameterRatchet = new RuntimeParameterRatchet(er);
+
+    const root: StoredRuntimeParameter = await drpp.readParameter('test', 'test1');
+    const override: StoredRuntimeParameter = await er.readParameter('test', 'test1');
+    const fetched: string = await rpr.fetchParameter<string>('test', 'test1');
+
+    expect(root).not.toBeNull();
+    expect(override).not.toBeNull();
+    expect(fetched).not.toBeNull();
+
+    expect(root.paramValue).toEqual('"not-overridden"');
+    expect(override.paramValue).toEqual('"override"');
+    expect(fetched).toEqual('override');
+  }, 30_000);
+});

package/src/runtime-parameter/global-variable-override-runtime-parameter-provider.ts

@@ -0,0 +1,82 @@
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+/**
+ * Provides parameters for a runtime parameter from an global (ie, process.env or global.xx) variable, where the key follows
+ * a given format
+ *
+ * "Simple" because it forces all ttls to be the same value (ignores what is passed in) so that the
+ * envvar itself can be just a string instead of a complex value
+ */
+export class GlobalVariableOverrideRuntimeParameterProvider implements RuntimeParameterProvider {
+  private options: GlobalVariableOverrideRuntimeParameterProviderOptions = {
+    globalTTL: 1,
+    separator: '.',
+    prefix: 'RuntimeEnv-',
+    suffix: '',
+  };
+
+  constructor(
+    private wrapped: RuntimeParameterProvider,
+    opts?: GlobalVariableOverrideRuntimeParameterProviderOptions,
+  ) {
+    // They can be empty but they cannot be null
+    RequireRatchet.notNullOrUndefined(this.wrapped, 'wrapped');
+    RequireRatchet.notNullOrUndefined(global?.process?.env, '"process" not found - this only runs in Node, not the browser');
+
+    if (opts) {
+      this.options = opts;
+    }
+    RequireRatchet.notNullOrUndefined(this.options.globalTTL, 'this.options.globalTTL');
+    RequireRatchet.notNullOrUndefined(this.options.separator, 'this.options.separator');
+    RequireRatchet.true(this.options.globalTTL > 0, 'this.options.globalTTL must be larger than 0');
+  }
+
+  public generateName(groupId: string, paramKey: string): string {
+    return (
+      StringRatchet.trimToEmpty(this.options.prefix) +
+      groupId +
+      StringRatchet.trimToEmpty(this.options.separator) +
+      paramKey +
+      StringRatchet.trimToEmpty(this.options.suffix)
+    );
+  }
+
+  public async readParameter(groupId: string, paramKey: string): Promise<StoredRuntimeParameter> {
+    const asString = StringRatchet.trimToNull(process.env[this.generateName(groupId, paramKey)]);
+    if (asString && !StringRatchet.canParseAsJson(asString)) {
+      ErrorRatchet.throwFormattedErr(
+        'Cannot parse ENV override (%s / %s) as JSON - did you forget the quotes on a string?',
+        groupId,
+        paramKey,
+      );
+    }
+    const rval: StoredRuntimeParameter = asString
+      ? {
+          groupId: groupId,
+          paramKey: paramKey,
+          paramValue: asString,
+          ttlSeconds: this.options.globalTTL,
+        }
+      : await this.wrapped.readParameter(groupId, paramKey);
+    return rval;
+  }
+
+  public async readAllParametersForGroup(groupId: string): Promise<StoredRuntimeParameter[]> {
+    return this.wrapped.readAllParametersForGroup(groupId);
+  }
+
+  public async writeParameter(toStore: StoredRuntimeParameter): Promise<boolean> {
+    return this.wrapped.writeParameter(toStore);
+  }
+}
+
+export interface GlobalVariableOverrideRuntimeParameterProviderOptions {
+  globalTTL: number;
+  separator: string;
+  prefix?: string;
+  suffix?: string;
+}

package/src/runtime-parameter/memory-runtime-parameter-provider.ts

@@ -0,0 +1,42 @@
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+/**
+ * Very simple class, basically here just for unit testing although I suppose you could
+ * use it for something else
+ */
+export class MemoryRuntimeParameterProvider implements RuntimeParameterProvider {
+  private _data: Promise<Record<string, StoredRuntimeParameter>>;
+
+  constructor(private inData?: Promise<Record<string, StoredRuntimeParameter>>) {
+    if (inData) {
+      this._data = inData;
+    } else {
+      this._data = Promise.resolve({});
+    }
+  }
+
+  public async readParameter(groupId: string, paramKey: string): Promise<StoredRuntimeParameter> {
+    Logger.silly('Reading %s / %s from underlying db', groupId, paramKey);
+    const d: Record<string, StoredRuntimeParameter> = await this._data;
+    return d[groupId + '::' + paramKey] ?? null;
+  }
+
+  public async readAllParametersForGroup(groupId: string): Promise<StoredRuntimeParameter[]> {
+    const d: Record<string, StoredRuntimeParameter> = await this._data;
+    const out: StoredRuntimeParameter[] = [];
+    Object.keys(d).forEach((k) => {
+      if (k.startsWith(groupId)) {
+        out.push(d[k]);
+      }
+    });
+    return out;
+  }
+
+  public async writeParameter(toStore: StoredRuntimeParameter): Promise<boolean> {
+    const d: Record<string, StoredRuntimeParameter> = await this._data;
+    d[toStore.groupId + '::' + toStore.paramKey] = toStore;
+    return true;
+  }
+}

package/src/runtime-parameter/runtime-parameter-provider.ts

@@ -0,0 +1,12 @@
+/**
+ * Classes implementing RuntimeParameterProvider offer the ability to fetch a runtime parameter
+ * object from _somewhere_
+ * They do NOT handle local caching - the RuntimeParameterRatchet does that
+ */
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+
+export interface RuntimeParameterProvider {
+  readParameter(groupId: string, paramKey: string): Promise<StoredRuntimeParameter>;
+  readAllParametersForGroup(groupId: string): Promise<StoredRuntimeParameter[]>;
+  writeParameter(param: StoredRuntimeParameter): Promise<boolean>;
+}

package/src/runtime-parameter/runtime-parameter-ratchet.spec.ts

@@ -0,0 +1,53 @@
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+import { MemoryRuntimeParameterProvider } from './memory-runtime-parameter-provider.js';
+import { describe, expect, test } from 'vitest';
+
+const testEntry: StoredRuntimeParameter = { groupId: 'test', paramKey: 'test', paramValue: '15', ttlSeconds: 0.5 };
+const testEntry2: StoredRuntimeParameter = { groupId: 'test', paramKey: 'test1', paramValue: '20', ttlSeconds: 0.5 };
+
+describe('#runtimeParameterRatchet', function () {
+  test('fetch and cache a runtime parameter', async () => {
+    Logger.setLevel(LoggerLevelName.silly);
+    const mp: MemoryRuntimeParameterProvider = new MemoryRuntimeParameterProvider();
+    const rpr: RuntimeParameterRatchet = new RuntimeParameterRatchet(mp);
+
+    const stored: StoredRuntimeParameter = await rpr.storeParameter('test', 'test1', 15, 0.5);
+    Logger.info('Stored : %j', stored);
+
+    const cache1: number = await rpr.fetchParameter<number>('test', 'test1');
+    const cache1a: number = await rpr.fetchParameter<number>('test', 'test1');
+    const cache1b: number = await rpr.fetchParameter<number>('test', 'test1');
+    expect(cache1).toEqual(15);
+    expect(cache1a).toEqual(15);
+    expect(cache1b).toEqual(15);
+
+    await PromiseRatchet.wait(1000);
+
+    const cache2: number = await rpr.fetchParameter<number>('test', 'test1');
+    expect(cache2).toEqual(15);
+
+    const cacheMiss: number = await rpr.fetchParameter<number>('test', 'test-miss');
+    expect(cacheMiss).toBeNull();
+
+    const cacheDefault: number = await rpr.fetchParameter<number>('test', 'test-miss', 27);
+    expect(cacheDefault).toEqual(27);
+  }, 30_000);
+
+  test('reads underlying entries', async () => {
+    Logger.setLevel(LoggerLevelName.silly);
+    const mrpp: MemoryRuntimeParameterProvider = new MemoryRuntimeParameterProvider();
+    await mrpp.writeParameter(testEntry);
+    await mrpp.writeParameter(testEntry2);
+
+    const rpr: RuntimeParameterRatchet = new RuntimeParameterRatchet(mrpp);
+
+    const vals: StoredRuntimeParameter[] = await rpr.readUnderlyingEntries('test');
+
+    expect(vals).not.toBeFalsy();
+    expect(vals.length).toEqual(2);
+  }, 30_000);
+});

package/src/runtime-parameter/runtime-parameter-ratchet.ts

@@ -0,0 +1,84 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { CachedStoredRuntimeParameter } from './cached-stored-runtime-parameter.js';
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+
+export class RuntimeParameterRatchet {
+  private cache: Map<string, CachedStoredRuntimeParameter> = new Map<string, CachedStoredRuntimeParameter>();
+
+  constructor(private provider: RuntimeParameterProvider) {
+    RequireRatchet.notNullOrUndefined(this.provider);
+  }
+
+  public async fetchParameter<T>(groupId: string, paramKey: string, defaultValue: T = null, forceFreshRead = false): Promise<T> {
+    Logger.debug('Reading parameter %s / %s / Force : %s', groupId, paramKey, forceFreshRead);
+    const cached: CachedStoredRuntimeParameter = this.cache.get(RuntimeParameterRatchet.toCacheStoreKey(groupId, paramKey));
+
+    let rval: T = null;
+    const now: number = new Date().getTime();
+    if (!forceFreshRead && !!cached) {
+      const oldest: number = cached.ttlSeconds ? now - cached.ttlSeconds * 1000 : 0;
+      if (cached.storedEpochMS > oldest) {
+        Logger.silly('Fetched %s / %s from cache', groupId, paramKey);
+        rval = JSON.parse(cached.paramValue);
+      }
+    }
+    if (!rval) {
+      const temp: StoredRuntimeParameter = await this.readUnderlyingEntry(groupId, paramKey);
+      if (temp) {
+        this.addToCache(temp);
+        rval = JSON.parse(temp.paramValue);
+      }
+    }
+
+    rval = rval || defaultValue;
+
+    return rval;
+  }
+
+  public async fetchAllParametersForGroup(groupId: string): Promise<Map<string, any>> {
+    const all: StoredRuntimeParameter[] = await this.readUnderlyingEntries(groupId);
+    const rval: Map<string, any> = new Map<string, any>();
+    all.forEach((t) => {
+      rval.set(t.paramKey, JSON.parse(t.paramValue));
+      this.addToCache(t);
+    });
+    return rval;
+  }
+
+  public async readUnderlyingEntry(groupId: string, paramKey: string): Promise<StoredRuntimeParameter> {
+    return this.provider.readParameter(groupId, paramKey);
+  }
+
+  public async readUnderlyingEntries(groupId: string): Promise<StoredRuntimeParameter[]> {
+    return this.provider.readAllParametersForGroup(groupId);
+  }
+
+  public async storeParameter(groupId: string, paramKey: string, paramValue: any, ttlSeconds: number): Promise<StoredRuntimeParameter> {
+    const toStore: StoredRuntimeParameter = {
+      groupId: groupId,
+      paramKey: paramKey,
+      paramValue: JSON.stringify(paramValue),
+      ttlSeconds: ttlSeconds,
+    };
+    const _wrote: boolean = await this.provider.writeParameter(toStore);
+    return this.provider.readParameter(groupId, paramKey);
+  }
+  private static toCacheStoreKey(groupId: string, paramKey: string): string {
+    return groupId + ':::' + paramKey;
+  }
+
+  private addToCache(temp: StoredRuntimeParameter): void {
+    if (temp) {
+      const now: number = new Date().getTime();
+      const toStore: CachedStoredRuntimeParameter = Object.assign({ storedEpochMS: now }, temp);
+      this.cache.set(RuntimeParameterRatchet.toCacheStoreKey(temp.groupId, temp.paramKey), toStore);
+    }
+  }
+
+  public clearCache(): void {
+    Logger.debug('Clearing runtime parameter cache');
+    this.cache = new Map<string, CachedStoredRuntimeParameter>();
+  }
+}

package/src/runtime-parameter/stored-runtime-parameter.ts

@@ -0,0 +1,6 @@
+export interface StoredRuntimeParameter {
+  groupId: string;
+  paramKey: string;
+  paramValue: string;
+  ttlSeconds: number;
+}

package/src/s3/expanded-file-children.ts

@@ -0,0 +1,5 @@
+export interface ExpandedFileChildren {
+  link: string;
+  name: string;
+  size: number;
+}

package/src/s3/impl/s3-environment-service-provider.ts

@@ -0,0 +1,41 @@
+import { EnvironmentServiceProvider } from '../../environment/environment-service-provider.js';
+import { S3CacheRatchet } from '../s3-cache-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { StopWatch } from '@bitblit/ratchet-common/lang/stop-watch';
+import { S3Client } from '@aws-sdk/client-s3';
+import { S3CacheRatchetLike } from '../s3-cache-ratchet-like.js';
+
+/**
+ * Service for reading environmental variables from S3
+ */
+export class S3EnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+  private ratchet: S3CacheRatchetLike;
+
+  public constructor(private cfg: S3EnvironmentServiceProviderConfig) {
+    RequireRatchet.notNullOrUndefined(cfg);
+    RequireRatchet.notNullOrUndefined(cfg.bucketName);
+    RequireRatchet.notNullOrUndefined(cfg.region);
+    RequireRatchet.true(!!cfg.s3Override || !!cfg.region, 'You must set either region or S3Override');
+    const s3: S3Client = cfg.s3Override || new S3Client({ region: cfg.region });
+    this.ratchet = new S3CacheRatchet(s3, cfg.bucketName);
+  }
+
+  public async fetchConfig(name: string): Promise<T> {
+    const readPath: string = StringRatchet.trimToEmpty(this.cfg.pathPrefix) + name + StringRatchet.trimToEmpty(this.cfg.pathSuffix);
+    Logger.silly('S3EnvironmentServiceProvider:Request to read config from : %s / %s', this.cfg.bucketName, readPath);
+    const sw: StopWatch = new StopWatch();
+    const rval: T = await this.ratchet.fetchCacheFileAsObject<T>(readPath);
+    sw.log();
+    return rval;
+  }
+}
+
+export interface S3EnvironmentServiceProviderConfig {
+  s3Override?: S3Client;
+  bucketName: string;
+  region?: string;
+  pathPrefix?: string;
+  pathSuffix?: string;
+}

package/src/s3/impl/s3-expiring-code-provider.spec.ts

@@ -0,0 +1,63 @@
+import { S3ExpiringCodeProvider, S3ExpiringCodeProviderFileWrapper } from './s3-expiring-code-provider.js';
+import { PutObjectCommandOutput, PutObjectOutput } from '@aws-sdk/client-s3';
+import { ExpiringCode } from '../../expiring-code/expiring-code.js';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { mock, MockProxy } from 'vitest-mock-extended';
+
+import { S3CacheRatchetLike } from '../s3-cache-ratchet-like.js';
+
+let mockS3Ratchet: MockProxy<S3CacheRatchetLike>;
+const testCode: ExpiringCode = { code: '12345', context: 'ctx', expiresEpochMS: Date.now() + 100_000, tags: ['tag1'] };
+const testCode2: ExpiringCode = { code: '45678', context: 'ctx', expiresEpochMS: Date.now() + 100_000, tags: ['tag1'] };
+
+describe('#S3ExpiringCodeProvider', () => {
+  beforeEach(() => {
+    mockS3Ratchet = mock<S3CacheRatchetLike>();
+    mockS3Ratchet.getDefaultBucket.mockReturnValue('TEST-BUCKET');
+  });
+
+  test('Should fetch file', async () => {
+    const val: S3ExpiringCodeProvider = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+    const output: S3ExpiringCodeProviderFileWrapper = await val.fetchFile();
+
+    expect(output).not.toBeFalsy();
+    expect(output.data).not.toBeFalsy();
+    expect(output.lastModifiedEpochMS).not.toBeFalsy();
+  });
+
+  test('Should update file', async () => {
+    const val: S3ExpiringCodeProvider = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+    mockS3Ratchet.writeObjectToCacheFile.mockResolvedValue({} as unknown as PutObjectCommandOutput);
+
+    const wrote: PutObjectOutput = await val.updateFile([testCode]);
+
+    expect(wrote).not.toBeFalsy();
+  });
+
+  test('Should check code', async () => {
+    mockS3Ratchet.fetchCacheFileAsObject.mockResolvedValue({
+      data: [testCode],
+      lastModifiedEpochMS: 1234,
+    });
+    const val: S3ExpiringCodeProvider = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+
+    const testValidCode: boolean = await val.checkCode('12345', 'ctx', false);
+    const testInvalidCode: boolean = await val.checkCode('09876', 'ctx', false);
+
+    expect(testValidCode).toBeTruthy();
+    expect(testInvalidCode).toBeFalsy();
+  });
+
+  test('Should store code', async () => {
+    mockS3Ratchet.fetchCacheFileAsObject.mockResolvedValue({
+      data: [testCode],
+      lastModifiedEpochMS: 1234,
+    });
+    mockS3Ratchet.writeObjectToCacheFile.mockResolvedValue({} as unknown as PutObjectCommandOutput);
+    const val: S3ExpiringCodeProvider = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+
+    const output: boolean = await val.storeCode(testCode2);
+
+    expect(output).toBeTruthy();
+  });
+});

package/src/s3/impl/s3-expiring-code-provider.ts

@@ -0,0 +1,71 @@
+import { ExpiringCodeProvider } from '../../expiring-code/expiring-code-provider.js';
+import { ExpiringCode } from '../../expiring-code/expiring-code.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PutObjectOutput } from '@aws-sdk/client-s3';
+import { S3CacheRatchetLike } from '../s3-cache-ratchet-like.js';
+
+/* An implementation that puts all the values in a single JSON file in S3
+  This won't scale well at all for any kind of serious load, but is the easiest
+  solution for a very low traffic website since it doesn't require setting up tables,
+  provisioning, etc
+ */
+export class S3ExpiringCodeProvider implements ExpiringCodeProvider {
+  constructor(
+    private s3CacheRatchet: S3CacheRatchetLike,
+    private keyName: string,
+  ) {
+    RequireRatchet.notNullOrUndefined(s3CacheRatchet, 's3CacheRatchet');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(s3CacheRatchet.getDefaultBucket(), 's3CacheRatchet.defaultBucket');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(keyName, 'keyName');
+  }
+
+  public async fetchFile(): Promise<S3ExpiringCodeProviderFileWrapper> {
+    const rval: S3ExpiringCodeProviderFileWrapper = (await this.s3CacheRatchet.fetchCacheFileAsObject<S3ExpiringCodeProviderFileWrapper>(
+      this.keyName,
+    )) || {
+      data: [],
+      lastModifiedEpochMS: Date.now(),
+    };
+    return rval;
+  }
+
+  public async updateFile(vals: ExpiringCode[]): Promise<PutObjectOutput> {
+    const next: S3ExpiringCodeProviderFileWrapper = {
+      data: vals || [],
+      lastModifiedEpochMS: Date.now(),
+    };
+    next.data = next.data.filter((d) => d.expiresEpochMS > Date.now()); // Always strip out expired codes
+    Logger.info('Updating code file to %s codes', next.data.length);
+    const rval: PutObjectOutput = await this.s3CacheRatchet.writeObjectToCacheFile(this.keyName, next);
+    return rval;
+  }
+
+  public async checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean> {
+    const val: S3ExpiringCodeProviderFileWrapper = await this.fetchFile();
+    const rval: ExpiringCode = val.data.find(
+      (d) => d?.code?.toUpperCase() === code?.toUpperCase() && d?.context?.toUpperCase() === context?.toUpperCase(),
+    );
+    if (rval) {
+      if (deleteOnMatch || rval.expiresEpochMS < Date.now()) {
+        Logger.info('Stripping used/expired code from the database');
+        const newData: ExpiringCode[] = val.data.filter((d) => d != rval);
+        await this.updateFile(newData);
+      }
+    }
+
+    return !!rval && rval.expiresEpochMS > Date.now();
+  }
+
+  public async storeCode(code: ExpiringCode): Promise<boolean> {
+    const old: S3ExpiringCodeProviderFileWrapper = await this.fetchFile();
+    old.data.push(code);
+    const wrote: PutObjectOutput = await this.updateFile(old.data);
+    return !!wrote;
+  }
+}
+
+export interface S3ExpiringCodeProviderFileWrapper {
+  data: ExpiringCode[];
+  lastModifiedEpochMS: number;
+}

package/src/s3/impl/s3-prototype-dao-provider.spec.ts

@@ -0,0 +1,45 @@
+import { S3PrototypeDaoProvider } from './s3-prototype-dao-provider.js';
+import { S3Client } from '@aws-sdk/client-s3';
+import { describe, expect, test } from 'vitest';
+import { PrototypeDao } from '../../dao/prototype-dao.js';
+import { S3CacheRatchet } from '../s3-cache-ratchet.js';
+
+describe('#S3PrototypeDaoProvider', () => {
+  test.skip('Should save/load files', async () => {
+    const svc: PrototypeDao<TestPrototypeItem> = new PrototypeDao<TestPrototypeItem>(
+      new S3PrototypeDaoProvider(new S3CacheRatchet(new S3Client({}), 'some-bucket'), 'test-data.json'),
+    );
+    await svc.resetDatabase();
+
+    await svc.store({ fieldA: 1, fieldB: 'test1', type: 'a' });
+    await svc.store({ fieldA: 2, fieldB: 'test2', type: 'a' });
+    await svc.store({ fieldA: 2, fieldB: 'test3', type: 'b' });
+    await svc.store({ guid: 'forceGuid', fieldA: 4, fieldB: 'test4', type: 'c' });
+
+    const test1: TestPrototypeItem[] = await svc.fetchAll();
+    expect(test1.length).toBe(4);
+
+    const test2: TestPrototypeItem = await svc.fetchById('forceGuid');
+    expect(test2).not.toBeNull();
+    expect(test2.createdEpochMS).not.toBeNull();
+    expect(test2.updatedEpochMS).not.toBeNull();
+
+    const test3: TestPrototypeItem[] = await svc.searchByField('fieldA', 4);
+    expect(test3.length).toBe(1);
+    expect(test3[0].guid).toEqual('forceGuid');
+
+    const test4: TestPrototypeItem[] = await svc.searchByFieldMap({ type: 'a', fieldA: 2 });
+    expect(test4.length).toBe(1);
+
+    await svc.resetDatabase();
+  }, 300_000);
+});
+
+export interface TestPrototypeItem {
+  fieldA: number;
+  fieldB: string;
+  type: string;
+  createdEpochMS?: number;
+  updatedEpochMS?: number;
+  guid?: string;
+}