@kravc/dos 1.12.6 → 2.0.0-alpha.0

package/src/Operation/operations/Update.ts

@@ -0,0 +1,60 @@
+import Operation from '../Operation';
+import Component from '../../Component';
+
+/** Returns class for an update operation. */
+const Update = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ComponentClass: any,
+  componentAction: string = Operation.types.UPDATE
+): typeof Operation => {
+  if (!ComponentClass?.isComponent) {
+    throw new Error('Argument "ComponentClass" is undefined for "Update" operation' +
+      ' function');
+  }
+
+  ComponentClass = ComponentClass as unknown as typeof Component;
+
+  const componentTitle = ComponentClass.getTitle();
+  const componentTitleLower = componentTitle.toLowerCase();
+
+  /** Update operation class */
+  return class extends Operation {
+    /** Returns component class for an update operation. */
+    static get Component() {
+      return ComponentClass;
+    }
+
+    /** Returns component action name for an update operation. */
+    static get componentAction() {
+      return componentAction;
+    }
+
+    /** Returns update operation type. */
+    static get type() {
+      return Operation.types.UPDATE;
+    }
+
+    /** Returns possible errors for a read operation. */
+    static get errors() {
+      return {
+        ...super.errors,
+        DocumentNotFoundError: {
+          statusCode:  404,
+          description: `${componentTitle} is not found`
+        }
+      };
+    }
+
+    /** Returns query schema with a component ID. */
+    static get query() {
+      return {
+        id: {
+          description: `ID of ${componentTitleLower} to be updated`,
+          required: true
+        }
+      };
+    }
+  };
+};
+
+export default Update;

package/src/Operation/operations/__tests__/Create.test.ts

@@ -0,0 +1,153 @@
+import { Profile } from '../../../Document/__tests__/__helpers';
+import { createContext } from '../../../Context/__tests__/__helpers';
+import { Create, Operation } from '../../../';
+
+describe('Create(Document, actionMethod)', () => {
+  it('throws exception if component class is of invalid type', () => {
+    expect(() => Create({}))
+      .toThrow('Argument "ComponentClass" is undefined for "Create" operation function');
+  });
+
+  it('returns a create operation class for a document', () => {
+    const CreateOperation = Create(Profile);
+
+    expect(CreateOperation).toBeDefined();
+  });
+
+  describe('CreateOperation', () => {
+    const CreateProfile = Create(Profile);
+
+    describe('CreateOperation.isComponent', () => {
+      it('returns false', () => {
+        expect(CreateProfile.isComponent).toBeFalsy();
+      });
+    });
+
+    describe('CreateOperation.type', () => {
+      it('returns CREATE type', () => {
+        expect(CreateProfile.type).toEqual(Operation.types.CREATE);
+      });
+    });
+
+    describe('CreateOperation.isCreate', () => {
+      it('returns true', () => {
+        expect(CreateProfile.isCreate).toBeTruthy();
+      });
+    });
+
+    describe('CreateOperation.isUpdate', () => {
+      it('returns false', () => {
+        expect(CreateProfile.isUpdate).toBeFalsy();
+      });
+    });
+
+    describe('CreateOperation.Component', () => {
+      it('returns referenced component', () => {
+        expect(CreateProfile.Component).toEqual(Profile);
+      });
+    });
+
+    describe('CreateOperation.componentName', () => {
+      it('returns referenced component name', () => {
+        expect(CreateProfile.componentName).toEqual('Profile');
+      });
+    });
+
+    describe('CreateOperation.componentAction', () => {
+      it('returns create action name', () => {
+        expect(CreateProfile.componentAction).toEqual('create');
+      });
+    });
+
+    describe('CreateOperation.componentMutationSchema', () => {
+      it('returns component mutation schema', () => {
+        expect(CreateProfile.componentMutationSchema).toEqual(Profile.mutationSchema);
+      });
+    });
+
+    describe('CreateOperation.id', () => {
+      it('returns operation ID', () => {
+        expect(CreateProfile.id).toEqual('CreateProfile');
+      });
+    });
+
+    describe('CreateOperation.tags', () => {
+      it('returns operation tags', () => {
+        expect(CreateProfile.tags).toEqual([ 'Profile' ]);
+      });
+    });
+
+    describe('CreateOperation.summary', () => {
+      it('returns operation summary', () => {
+        expect(CreateProfile.summary).toEqual('Create profile');
+      });
+    });
+
+    describe('CreateOperation.description', () => {
+      it('returns operation description', () => {
+        expect(CreateProfile.description).toEqual('');
+      });
+    });
+
+    describe('CreateOperation.security', () => {
+      it('returns operation security requirements', () => {
+        expect(CreateProfile.security).toEqual([]);
+      });
+    });
+
+    describe('CreateOperation.errors', () => {
+      it('includes related errors', () => {
+        const errorCodes = Object.keys(CreateProfile.errors);
+        expect(errorCodes).toContain('InvalidInputError');
+        expect(errorCodes).toContain('InvalidOutputError');
+        expect(errorCodes).toContain('UnprocessibleConditionError');
+        expect(errorCodes).toContain('DocumentExistsError');
+      });
+    });
+
+    describe('UpdateOperation.query', () => {
+      it('returns null', () => {
+        expect(CreateProfile.query).toBeNull();
+      });
+    });
+
+    describe('CreateOperation.inputSchema', () => {
+      it('returns operation input schema', () => {
+        expect(CreateProfile.inputSchema).toBeDefined();
+      });
+    });
+
+    describe('CreateOperation.outputSchema', () => {
+      it('returns operation output schema', () => {
+        expect(CreateProfile.outputSchema).toBeDefined();
+      });
+    });
+
+    describe('CreateOperation.hasOutput', () => {
+      it('returns true', () => {
+        expect(CreateProfile.hasOutput).toBeTruthy();
+      });
+    });
+
+    describe('CreateOperation.componentActionMethod', () => {
+      it('returns binded component action method', () => {
+        expect(CreateProfile.componentActionMethod).toBeDefined();
+      });
+    });
+
+    describe('.exec(input)', () => {
+      it('creates document', async () => {
+        const context = createContext({ request: { operationId: 'CreateProfile' } });
+        const operation = new CreateProfile(context);
+        const input = { mutation: { name: 'John Doe' } };
+
+        const { result, headers, multiValueHeaders } = await operation.exec(input);
+
+        expect(headers).toEqual({});
+        expect(multiValueHeaders).toEqual({});
+
+        expect((result.data as Profile).attributes.name).toEqual('John Doe');
+      });
+    });
+  });
+});

package/src/Operation/operations/__tests__/Delete.test.ts

@@ -0,0 +1,163 @@
+import { Profile } from '../../../Document/__tests__/__helpers';
+import { createContext } from '../../../Context/__tests__/__helpers';
+import { Delete, Operation } from '../../../';
+
+describe('Delete(Document, actionMethod)', () => {
+  it('throws exception if component class is of invalid type', () => {
+    expect(() => Delete({}))
+      .toThrow('Argument "ComponentClass" is undefined for "Delete" operation function');
+  });
+
+  it('returns a delete operation class for a document', () => {
+    const DeleteOperation = Delete(Profile);
+
+    expect(DeleteOperation).toBeDefined();
+  });
+
+  describe('DeleteOperation', () => {
+    const DeleteProfile = Delete(Profile);
+
+    describe('DeleteOperation.isComponent', () => {
+      it('returns false', () => {
+        expect(DeleteProfile.isComponent).toBeFalsy();
+      });
+    });
+
+    describe('DeleteOperation.type', () => {
+      it('returns DELETE type', () => {
+        expect(DeleteProfile.type).toEqual(Operation.types.DELETE);
+      });
+    });
+
+    describe('DeleteOperation.isCreate', () => {
+      it('returns false', () => {
+        expect(DeleteProfile.isCreate).toBeFalsy();
+      });
+    });
+
+    describe('DeleteOperation.isUpdate', () => {
+      it('returns false', () => {
+        expect(DeleteProfile.isUpdate).toBeFalsy();
+      });
+    });
+
+    describe('DeleteOperation.Component', () => {
+      it('returns referenced component', () => {
+        expect(DeleteProfile.Component).toEqual(Profile);
+      });
+    });
+
+    describe('DeleteOperation.componentName', () => {
+      it('returns referenced component name', () => {
+        expect(DeleteProfile.componentName).toEqual('Profile');
+      });
+    });
+
+    describe('DeleteOperation.componentAction', () => {
+      it('returns delete action name', () => {
+        expect(DeleteProfile.componentAction).toEqual('delete');
+      });
+    });
+
+    describe('DeleteOperation.componentMutationSchema', () => {
+      it('returns component mutation schema', () => {
+        expect(DeleteProfile.componentMutationSchema).toEqual(Profile.mutationSchema);
+      });
+    });
+
+    describe('DeleteOperation.id', () => {
+      it('returns operation ID', () => {
+        expect(DeleteProfile.id).toEqual('DeleteProfile');
+      });
+    });
+
+    describe('DeleteOperation.tags', () => {
+      it('returns operation tags', () => {
+        expect(DeleteProfile.tags).toEqual([ 'Profile' ]);
+      });
+    });
+
+    describe('DeleteOperation.summary', () => {
+      it('returns operation summary', () => {
+        expect(DeleteProfile.summary).toEqual('Delete profile');
+      });
+    });
+
+    describe('DeleteOperation.description', () => {
+      it('returns operation description', () => {
+        expect(DeleteProfile.description).toEqual('');
+      });
+    });
+
+    describe('DeleteOperation.security', () => {
+      it('returns operation security requirements', () => {
+        expect(DeleteProfile.security).toEqual([]);
+      });
+    });
+
+    describe('DeleteOperation.errors', () => {
+      it('includes related errors', () => {
+        const errorCodes = Object.keys(DeleteProfile.errors);
+        expect(errorCodes).toContain('InvalidInputError');
+        expect(errorCodes).toContain('UnprocessibleConditionError');
+        expect(errorCodes).toContain('DocumentNotFoundError');
+      });
+    });
+
+    describe('DeleteOperation.query', () => {
+      it('includes ID parameters', () => {
+        expect(DeleteProfile.query!.id).toEqual({
+          description: 'ID of profile to be deleted',
+          required: true
+        });
+      });
+    });
+
+    describe('DeleteOperation.inputSchema', () => {
+      it('returns operation input schema', () => {
+        expect(DeleteProfile.inputSchema).toBeDefined();
+      });
+    });
+
+    describe('DeleteOperation.output', () => {
+      it('returns null', () => {
+        expect(DeleteProfile.output).toBeNull();
+      });
+    });
+
+    describe('DeleteOperation.outputSchema', () => {
+      it('returns operation output schema', () => {
+        expect(DeleteProfile.outputSchema).toBeDefined();
+      });
+    });
+
+    describe('DeleteOperation.hasOutput', () => {
+      it('returns false', () => {
+        expect(DeleteProfile.hasOutput).toBeFalsy();
+      });
+    });
+
+    describe('DeleteOperation.componentActionMethod', () => {
+      it('returns binded component action method', () => {
+        expect(DeleteProfile.componentActionMethod).toBeDefined();
+      });
+    });
+
+    describe('.exec(input)', () => {
+      it('deletes document', async () => {
+        const context = createContext({ request: { operationId: 'DeleteProfile' } });
+        const { id } = await Profile.create(context, { name: 'John Doe' });
+
+        const operation = new DeleteProfile(context);
+        const input = { id };
+
+        const { result, headers, multiValueHeaders } = await operation.exec(input);
+
+        expect(headers).toEqual({});
+        expect(multiValueHeaders).toEqual({});
+
+        expect((result.data as Profile).attributes.name).toEqual('John Doe');
+      });
+    });
+  });
+});

package/src/Operation/operations/__tests__/Index.test.ts

@@ -0,0 +1,209 @@
+import { Profile } from '../../../Document/__tests__/__helpers';
+import { createContext } from '../../../Context/__tests__/__helpers';
+import type { PageInfo } from '../Index';
+import { Index, Operation } from '../../../';
+
+describe('Index(Document, actionMethod)', () => {
+  it('throws exception if component class is of invalid type', () => {
+    expect(() => Index({}))
+      .toThrow('Argument "ComponentClass" is undefined for "Index" operation function');
+  });
+
+  it('returns an index operation class for a document', () => {
+    const IndexOperation = Index(Profile);
+
+    expect(IndexOperation).toBeDefined();
+  });
+
+  describe('IndexOperation', () => {
+    const IndexProfiles = Index(Profile);
+
+    describe('IndexOperation.isComponent', () => {
+      it('returns false', () => {
+        expect(IndexProfiles.isComponent).toBeFalsy();
+      });
+    });
+
+    describe('IndexOperation.type', () => {
+      it('returns READ type', () => {
+        expect(IndexProfiles.type).toEqual(Operation.types.READ);
+      });
+    });
+
+    describe('IndexOperation.isCreate', () => {
+      it('returns false', () => {
+        expect(IndexProfiles.isCreate).toBeFalsy();
+      });
+    });
+
+    describe('IndexOperation.isUpdate', () => {
+      it('returns false', () => {
+        expect(IndexProfiles.isUpdate).toBeFalsy();
+      });
+    });
+
+    describe('IndexOperation.Component', () => {
+      it('returns referenced component', () => {
+        expect(IndexProfiles.Component).toEqual(Profile);
+      });
+    });
+
+    describe('IndexOperation.componentName', () => {
+      it('returns referenced component name', () => {
+        expect(IndexProfiles.componentName).toEqual('Profile');
+      });
+    });
+
+    describe('IndexOperation.componentAction', () => {
+      it('returns index action name', () => {
+        expect(IndexProfiles.componentAction).toEqual('index');
+      });
+    });
+
+    describe('IndexOperation.id', () => {
+      it('returns operation ID', () => {
+        expect(IndexProfiles.id).toEqual('IndexProfiles');
+      });
+    });
+
+    describe('IndexOperation.tags', () => {
+      it('returns operation tags', () => {
+        expect(IndexProfiles.tags).toEqual([ 'Profile' ]);
+      });
+    });
+
+    describe('IndexOperation.summary', () => {
+      it('returns operation summary', () => {
+        expect(IndexProfiles.summary).toEqual('Index profiles');
+      });
+    });
+
+    describe('IndexOperation.description', () => {
+      it('returns operation description', () => {
+        expect(IndexProfiles.description).toEqual('');
+      });
+    });
+
+    describe('IndexOperation.security', () => {
+      it('returns operation security requirements', () => {
+        expect(IndexProfiles.security).toEqual([]);
+      });
+    });
+
+    describe('IndexOperation.errors', () => {
+      it('includes related errors', () => {
+        const errorCodes = Object.keys(IndexProfiles.errors);
+        expect(errorCodes).toContain('InvalidInputError');
+        expect(errorCodes).toContain('InvalidOutputError');
+        expect(errorCodes).toContain('UnprocessibleConditionError');
+      });
+    });
+
+    describe('IndexOperation.query', () => {
+      it('returns pagination parameters', () => {
+        expect(IndexProfiles.query).toEqual({
+          limit: {
+            type: 'integer',
+            example: 20,
+            default: 20,
+            minimum: 1,
+            maximum: 999,
+            description: 'Limit number of profiles to be returned',
+          },
+          sort: {
+            enum: ['asc', 'desc'],
+            default: 'desc',
+            description: 'Sort direction',
+          },
+          exclusiveStartKey: {
+            description: 'Exclusive start key to return next batch of profiles',
+          }
+        });
+      });
+    });
+
+    describe('IndexOperation.inputSchema', () => {
+      it('returns operation input schema', () => {
+        expect(IndexProfiles.inputSchema).toBeDefined();
+      });
+    });
+
+    describe('IndexOperation.output', () => {
+      it('returns output', () => {
+        expect(IndexProfiles.output).toEqual({
+          data: {
+            items: {
+              $ref: 'Profile',
+            },
+            required: true,
+          },
+          pageInfo: {
+            required: true,
+            properties: {
+              sort: {
+                enum: ['asc', 'desc'],
+                description: 'Sort direction',
+              },
+              count: {
+                type: 'integer',
+                example: 0,
+                description: 'Number of profiles',
+              },
+              limit: {
+                type: 'integer',
+                example: 100,
+                description: 'Limit number of profiles to be returned',
+              },
+              lastEvaluatedKey: {
+                description: 'Last evaluated key to get next batch of profiles',
+              },
+            }
+          }
+        });
+      });
+    });
+
+    describe('IndexOperation.outputSchema', () => {
+      it('returns operation output schema', () => {
+        expect(IndexProfiles.outputSchema).toBeDefined();
+      });
+    });
+
+    describe('IndexOperation.hasOutput', () => {
+      it('returns true', () => {
+        expect(IndexProfiles.hasOutput).toBeTruthy();
+      });
+    });
+
+    describe('IndexOperation.componentActionMethod', () => {
+      it('returns binded component action method', () => {
+        expect(IndexProfiles.componentActionMethod).toBeDefined();
+      });
+    });
+
+    describe('.exec(input)', () => {
+      it('index documents', async () => {
+        const context = createContext({ request: { operationId: 'IndexProfiles' } });
+        const { id } = await Profile.create(context, { name: 'John Doe' });
+
+        const operation = new IndexProfiles(context);
+
+        const input = {
+          sort: 'desc',
+          limit: 20,
+        };
+
+        const { result, headers, multiValueHeaders } = await operation.exec(input);
+
+        expect(headers).toEqual({});
+        expect(multiValueHeaders).toEqual({});
+
+        expect((result.data as Profile[])[0].id).toEqual(id);
+        expect((result.pageInfo as PageInfo).sort).toEqual('desc');
+        expect((result.pageInfo as PageInfo).count).toEqual(1);
+        expect((result.pageInfo as PageInfo).limit).toEqual(20);
+        expect((result.pageInfo as PageInfo).lastEvaluatedKey).toBeUndefined();
+      });
+    });
+  });
+});