feat(model): auto-managed createdAt and updatedAt fields

src/base-model.ts

@@ -24,6 +24,12 @@ import ValidationError from './validation-error';
 import { PutCommandInput } from '@aws-sdk/lib-dynamodb/dist-types/commands/PutCommand';
 
 export type KeyValue = string | number | Buffer | boolean | null;
+
+export interface UpToDateEntity {
+  createdAt?: string;
+  updatedAt?: string;
+}
+
 type SimpleKey = KeyValue;
 type CompositeKey = { pk: KeyValue; sk: KeyValue };
 type Keys = SimpleKey[] | CompositeKey[];
@@ -44,6 +50,10 @@ export default abstract class Model<T> {
 
   protected schema: ObjectSchema | undefined;
 
+  protected autoCreatedAt = false;
+
+  protected autoUpdatedAt = false;
+
   constructor(item?: T, options?: DynamoDBClientConfig, translateConfig?: TranslateConfig) {
     this.item = item;
     const client = new DynamoDBClient(options ?? { region: process.env.AWS_REGION });
@@ -163,6 +173,9 @@ export default abstract class Model<T> {
       error.name = 'E_ALREADY_EXISTS';
       throw error;
     }
+    if (this.autoCreatedAt) {
+      (toCreate as T & UpToDateEntity).createdAt = new Date().toISOString();
+    }
     // Save item
     return this.save(toCreate, putOptions);
   }
@@ -204,6 +217,9 @@ export default abstract class Model<T> {
         throw new ValidationError('Validation error', error);
       }
     }
+    if (this.autoUpdatedAt) {
+      (toSave as T & UpToDateEntity).updatedAt = new Date().toISOString();
+    }
     // Prepare putItem operation
     const params: PutCommandInput = {
       TableName: this.tableName,
@@ -537,6 +553,12 @@ export default abstract class Model<T> {
       nativeOptions = options;
     }
     this.testKeys(pk, sk);
+    if (this.autoUpdatedAt) {
+      updateActions['updatedAt'] = {
+        action: "PUT",
+        value: new Date().toISOString(),
+      }
+    }
     const params: UpdateCommandInput = {
       TableName: this.tableName,
       Key: this.buildKeys(pk, sk),

test/create.spec.ts

@@ -2,11 +2,15 @@ import { clearTables } from './hooks/create-tables';
 import HashKeyModel from './models/hashkey';
 import HashKeyJoiModel from './models/hashkey-joi';
 import CompositeKeyModel from './models/composite-keys';
+import HashKeyUpToDateModel from './models/hashkey-up-to-date';
 
 describe('The create method', () => {
   beforeEach(async () => {
     await clearTables();
   });
+  afterEach(async () => {
+    jest.resetAllMocks();
+  });
   test('should save the item held by the class', async () => {
     const item = {
       hashkey: 'bar',
@@ -25,6 +29,48 @@ describe('The create method', () => {
     const saved = await foo.get('bar');
     expect(saved).toEqual(item);
   });
+  test('should not override date when autoCreatedAt is false', async () => {
+    const item = {
+      hashkey: 'bar',
+      string: 'whatever',
+      stringmap: { foo: 'bar' },
+      stringset: ['bar, bar'],
+      number: 43,
+      bool: true,
+      list: ['foo', 42],
+      createdAt: '2023-08-09T10:11:12.131Z',
+    };
+    const foo = new HashKeyModel(item);
+    expect(foo.getItem()).toBe(item);
+    await foo.create({
+      ReturnConsumedCapacity: 'NONE',
+    });
+    const saved = await foo.get('bar');
+    expect(saved).toEqual(item);
+  });
+  test('should save the item with autoCreatedAt field and autoUpdatedAt field', async () => {
+    const item = {
+      hashkey: 'bar',
+      string: 'whatever',
+      stringmap: { foo: 'bar' },
+      stringset: ['bar, bar'],
+      number: 43,
+      bool: true,
+      list: ['foo', 42],
+    };
+    const expectedItem = {
+      ...item,
+      createdAt: '2023-11-10T14:36:39.297Z',
+      updatedAt: '2023-11-10T14:36:39.297Z',
+    }
+    const foo = new HashKeyUpToDateModel(item);
+    jest.spyOn(Date.prototype, 'toISOString').mockImplementation(() => '2023-11-10T14:36:39.297Z');
+    await foo.create({
+      ReturnConsumedCapacity: 'NONE',
+    });
+    const saved = await foo.get('bar');
+    expect(saved).toEqual(expectedItem);
+  });
   test('should throw an error if not item is held by the class', async () => {
     const foo = new HashKeyModel();
     try {

test/models/hashkey-up-to-date.ts

@@ -0,0 +1,15 @@
+import Model, { UpToDateEntity } from '../../src/base-model';
+import documentClient from './common';
+import { HashKeyEntity } from './hashkey';
+
+export default class HashKeyUpToDateModel extends Model<HashKeyEntity & UpToDateEntity> {
+  protected tableName = 'table_test_hashkey';
+
+  protected pk = 'hashkey';
+
+  protected documentClient = documentClient;
+
+  protected autoCreatedAt = true;
+
+  protected autoUpdatedAt = true;
+}

test/save.spec.ts

@@ -1,6 +1,7 @@
 import { clearTables } from './hooks/create-tables';
 import HashKeyModel from './models/hashkey';
 import HashKeyJoiModel from './models/hashkey-joi';
+import HashKeyUpToDateModel from './models/hashkey-up-to-date';
 
 describe('The save method', () => {
   beforeEach(async () => {
@@ -21,6 +22,26 @@ describe('The save method', () => {
     const saved = await foo.get('bar');
     expect(saved).toEqual(item);
   });
+  test('should save the item with updatedAt field', async () => {
+    jest.spyOn(Date.prototype, 'toISOString').mockImplementation(() => '2023-11-10T14:36:39.297Z');
+    const item = {
+      hashkey: 'bar',
+      string: 'whatever',
+      stringmap: { foo: 'bar' },
+      stringset: ['bar, bar'],
+      number: 43,
+      bool: true,
+      list: ['foo', 42],
+    };
+    const savedItem = {
+      ...item,
+      updatedAt: '2023-11-10T14:36:39.297Z'
+    }
+    const foo = new HashKeyUpToDateModel(item);
+    await foo.save();
+    const saved = await foo.get('bar');
+    expect(saved).toEqual(savedItem);
+  });
   test('should throw an error if not item is held by the class', async () => {
     const foo = new HashKeyModel();
     try {

test/update.spec.ts

@@ -1,10 +1,12 @@
 import HashKeyModel from './models/hashkey';
 import { clearTables } from './hooks/create-tables';
 import { put, remove } from '../src';
+import HashKeyUpToDateModel from './models/hashkey-up-to-date';
 
 describe('The update method', () => {
   const model = new HashKeyModel();
-  beforeAll(async () => {
+  const modelUpToDate = new HashKeyUpToDateModel();
+  beforeEach(async () => {
     await clearTables();
     await model.save({
       hashkey: 'hashkey',
@@ -19,6 +21,19 @@ describe('The update method', () => {
       optionalList: [42, 'foo'],
       optionalStringmap: { bar: 'baz' },
     });
+    await modelUpToDate.save({
+      hashkey: 'hashkeyUpToDate',
+      number: 42,
+      bool: true,
+      string: 'string',
+      stringset: ['string', 'string'],
+      list: [42, 'foo'],
+      stringmap: { bar: 'baz' },
+      optionalNumber: 42,
+      optionalStringset: ['string', 'string'],
+      optionalList: [42, 'foo'],
+      optionalStringmap: { bar: 'baz' },
+    });
   });
   test('should update the item with the correct actions', async () => {
     await model.update('hashkey', {
@@ -42,6 +57,55 @@ describe('The update method', () => {
       optionalStringmap: { bar: 'baz' },
     });
   });
+  test('should update the item with updatedAt field', async () => {
+    jest.spyOn(Date.prototype, 'toISOString').mockImplementation(() => '2023-11-10T14:36:39.297Z');
+    await modelUpToDate.update('hashkeyUpToDate', {
+      number: put(43),
+      bool: put(null),
+      optionalNumber: remove(),
+    });
+    const updated = await modelUpToDate.get('hashkeyUpToDate');
+    expect(updated).toEqual({
+      hashkey: 'hashkeyUpToDate',
+      number: 43,
+      bool: null,
+      string: 'string',
+      stringset: ['string', 'string'],
+      list: [42, 'foo'],
+      stringmap: { bar: 'baz' },
+      optionalStringset: ['string', 'string'],
+      optionalList: [42, 'foo'],
+      optionalStringmap: { bar: 'baz' },
+      updatedAt: '2023-11-10T14:36:39.297Z',
+    });
+  });
+  test('should update the item with updatedAt field a second time', async () => {
+    await modelUpToDate.update('hashkeyUpToDate', {
+      number: put(43),
+      bool: put(null),
+      optionalNumber: remove(),
+    });
+    jest.spyOn(Date.prototype, 'toISOString').mockImplementation(() => '2023-12-10T14:36:39.297Z');
+    await modelUpToDate.update('hashkeyUpToDate', {
+      number: put(43),
+      bool: put(null),
+      optionalNumber: remove(),
+    });
+    const updated = await modelUpToDate.get('hashkeyUpToDate');
+    expect(updated).toEqual({
+      hashkey: 'hashkeyUpToDate',
+      number: 43,
+      bool: null,
+      string: 'string',
+      stringset: ['string', 'string'],
+      list: [42, 'foo'],
+      stringmap: { bar: 'baz' },
+      optionalStringset: ['string', 'string'],
+      optionalList: [42, 'foo'],
+      optionalStringmap: { bar: 'baz' },
+      updatedAt: '2023-12-10T14:36:39.297Z',
+    });
+  });
   test.todo('should throw if item doest not exist');
   test.todo('should throw is hash key is not given');
 });