@envoy/envoy-integrations-sdk 2.0.1-beta.5 → 2.0.2

package/src/factories/entryEventBodyFactory.ts

@@ -0,0 +1,124 @@
+import { Sync, each } from 'factory.ts';
+import faker from 'faker';
+
+import EntryPayload from '../payloads/EntryPayload';
+import EnvoyEntryEvent from '../internal/EnvoyEntryEvent';
+import { EnvoyUserAPIScope } from '../sdk/EnvoyUserAPI';
+import eventBodyFactory from './eventBodyFactory';
+
+export type EntryPayloadFactoryVisitorOptions = {
+  isProtectFlow: false,
+  isSignedIn: boolean,
+  hasEmail: boolean,
+  hasHost: boolean,
+  hasInvite: boolean,
+  hasDevice: boolean,
+  hasPhoneNumber?: boolean,
+  hasPhoto?: boolean,
+};
+
+export type EntryPayloadFactoryProtectOptions = {
+  isProtectFlow: true,
+  isSignedIn: boolean,
+  hasPhoneNumber?: boolean,
+  hasPhoto?: boolean,
+};
+
+export type EntryPayloadFactoryOptions = EntryPayloadFactoryVisitorOptions | EntryPayloadFactoryProtectOptions;
+
+export const entryEventBodyFactoryDefaultIds = {
+  location: '1',
+  company: '1',
+  flow: '1',
+  invite: '1',
+  device: '1',
+  employee: '1',
+};
+
+export function entryPayloadFactory(
+  options: EntryPayloadFactoryOptions,
+  ids: Partial<typeof entryEventBodyFactoryDefaultIds> = entryEventBodyFactoryDefaultIds,
+): Sync.Factory<EntryPayload> {
+  const signedInDate = faker.date.past();
+  const allIds = { ...entryEventBodyFactoryDefaultIds, ...ids };
+  return Sync.makeFactory<EntryPayload>({
+    id: each((i) => `${i + 1}`),
+    type: 'entries',
+    attributes: {
+      'full-name': faker.name.findName(),
+      'phone-number': options.hasPhoneNumber ? faker.phone.phoneNumber() : undefined,
+      email: (options.isProtectFlow || options.hasEmail) ? faker.internet.email() : null,
+      'employee-screening-flow': options.isProtectFlow,
+      host: (!options.isProtectFlow && options.hasHost) ? faker.name.findName() : null,
+      'host-email': (!options.isProtectFlow && options.hasHost) ? faker.internet.email() : null,
+      'private-notes': null,
+      'signed-in-at': signedInDate.toISOString(),
+      'signed-out-at': options.isSignedIn ? undefined : faker.date.between(signedInDate, new Date()).toISOString(),
+      thumbnails: options.hasPhoto ? {
+        large: faker.image.avatar(),
+        original: faker.image.avatar(),
+        small: faker.image.avatar(),
+      } : {
+        large: null,
+        original: null,
+        small: null,
+      },
+      'flow-name': options.isProtectFlow ? 'Employee registration' : 'Visitor',
+      'user-data': [] as Array<{ field: string, value: string | null }>,
+    },
+    relationships: {
+      location: {
+        data: {
+          id: allIds.location,
+          type: 'locations',
+        },
+      },
+      flow: {
+        data: {
+          id: allIds.flow,
+          type: 'flows',
+        },
+      },
+      invite: (options.isProtectFlow || options.hasInvite) ? {
+        data: {
+          id: allIds.invite,
+          type: 'invites',
+        },
+      } : undefined,
+      device: (!options.isProtectFlow && options.hasDevice) ? {
+        data: {
+          id: allIds.device,
+          type: 'devices',
+        },
+      } : undefined,
+      employee: (options.isProtectFlow || options.hasHost) ? {
+        data: {
+          id: allIds.employee,
+          type: 'employees',
+        },
+      } : undefined,
+    },
+  });
+}
+
+export type EntryEventBodyFactoryOptions<Config extends Record<string, unknown> = Record<string, never>> = {
+  event: EnvoyEntryEvent,
+  config: Partial<Config>,
+  payloadOptions: EntryPayloadFactoryOptions,
+  scope?: Array<EnvoyUserAPIScope>,
+  ids?: Partial<typeof entryEventBodyFactoryDefaultIds>,
+};
+
+export default function entryEventBodyFactory<Config extends Record<string, unknown> = Record<string, never>>(
+  options: EntryEventBodyFactoryOptions<Config>,
+) {
+  const ids = options.ids || entryEventBodyFactoryDefaultIds;
+  return eventBodyFactory<EnvoyEntryEvent, Config, EntryPayload>({
+    event: options.event,
+    config: options.config,
+    scope: options.scope || [],
+    locationId: options.ids?.location || entryEventBodyFactoryDefaultIds.location,
+    companyId: options.ids?.company || entryEventBodyFactoryDefaultIds.company,
+    payload: entryPayloadFactory(options.payloadOptions, ids).build(),
+  });
+}

package/src/factories/eventBodyFactory.ts

@@ -0,0 +1,35 @@
+import { EnvoyUserAPIScope } from '../sdk/EnvoyUserAPI';
+import { eventMetaFactory } from './metaFactory';
+
+export const eventBodyFactoryDefaultIds = {
+  locationId: '1',
+  companyId: '1',
+};
+
+export type EventBodyFactoryOptions<Event, Config, Payload> = {
+  event: Event,
+  config: Partial<Config>,
+  payload: Payload,
+  scope: Array<EnvoyUserAPIScope>,
+  locationId?: string,
+  companyId?: string,
+};
+
+export default function eventBodyFactory<
+  Event extends string = string,
+  Config extends Record<string, unknown> = Record<string, never>,
+  Payload extends Record<string, unknown> = Record<string, never>,
+  >(
+  options: EventBodyFactoryOptions<Event, Config, Payload>,
+) {
+  return {
+    meta: eventMetaFactory<Config>(
+      options.event,
+      options.config,
+      options.scope,
+      options.locationId || eventBodyFactoryDefaultIds.locationId,
+      options.companyId || eventBodyFactoryDefaultIds.companyId,
+    ).build(),
+    payload: options.payload,
+  };
+}

package/src/factories/inviteEventBodyFactory.ts

@@ -0,0 +1,107 @@
+import { Sync, each } from 'factory.ts';
+import faker from 'faker';
+
+import InvitePayload from '../payloads/InvitePayload';
+import EnvoyInviteEvent from '../internal/EnvoyInviteEvent';
+import { EnvoyUserAPIScope } from '../sdk/EnvoyUserAPI';
+import eventBodyFactory from './eventBodyFactory';
+
+export type InvitePayloadFactoryVisitorOptions = {
+  isProtectFlow: false,
+  hasEmail: boolean,
+  hasHost: boolean,
+  preregistrationComplete: boolean,
+  hasPhoto?: boolean,
+};
+
+export type InvitePayloadFactoryProtectOptions = {
+  isProtectFlow: true,
+  preregistrationComplete: boolean,
+  hasPhoto?: boolean,
+};
+
+export type InvitePayloadFactoryOptions = InvitePayloadFactoryVisitorOptions | InvitePayloadFactoryProtectOptions;
+
+export const inviteEventBodyFactoryDefaultIds = {
+  location: '1',
+  company: '1',
+  flow: '1',
+  invite: '1',
+  device: '1',
+  employee: '1',
+};
+
+export function invitePayloadFactory(
+  options: InvitePayloadFactoryOptions,
+  ids: Partial<typeof inviteEventBodyFactoryDefaultIds> = inviteEventBodyFactoryDefaultIds,
+): Sync.Factory<InvitePayload> {
+  const signedInDate = faker.date.past();
+  const allIds = { ...inviteEventBodyFactoryDefaultIds, ...ids };
+  return Sync.makeFactory<InvitePayload>({
+    id: each((i) => `${i + 1}`),
+    type: 'invites',
+    attributes: {
+      'employee-screening-flow': options.isProtectFlow,
+      'full-name': faker.name.findName(),
+      email: (options.isProtectFlow || options.hasEmail) ? faker.internet.email() : null,
+      'inviter-name': (!options.isProtectFlow && options.hasHost) ? faker.name.findName() : null,
+      'inviter-email': (!options.isProtectFlow && options.hasHost) ? faker.internet.email() : null,
+      'expected-arrival-time': faker.date.future().toISOString(),
+      'private-notes': null,
+      arrived: false,
+      'been-here-before': false,
+      'flow-name': options.isProtectFlow ? 'Employee registration' : 'Visitor',
+      'flow-id': allIds.flow,
+      'user-data': [] as Array<{ field: string, value: string | null }>,
+      'secret-token': faker.random.alphaNumeric(10),
+      'edit-token': faker.random.alphaNumeric(10),
+      'photo-url': faker.image.avatar(),
+      'qr-code': null,
+      'qr-code-sent-at': null,
+      'preregistration-complete': options.preregistrationComplete,
+      'reminder-sent-at': null,
+    },
+    relationships: {
+      location: {
+        data: {
+          id: allIds.location,
+          type: 'locations',
+        },
+      },
+      flow: {
+        data: {
+          id: allIds.flow,
+          type: 'flows',
+        },
+      },
+      employee: (options.isProtectFlow || options.hasHost) ? {
+        data: {
+          id: allIds.employee,
+          type: 'employees',
+        },
+      } : undefined,
+    },
+  });
+}
+
+export type InviteEventBodyFactoryOptions<Config extends Record<string, unknown> = Record<string, never>> = {
+  event: EnvoyInviteEvent,
+  config: Partial<Config>,
+  payloadOptions: InvitePayloadFactoryOptions,
+  scope?: Array<EnvoyUserAPIScope>,
+  ids?: Partial<typeof inviteEventBodyFactoryDefaultIds>,
+};
+
+export default function entryEventBodyFactory<Config extends Record<string, unknown> = Record<string, never>>(
+  options: InviteEventBodyFactoryOptions<Config>,
+) {
+  const ids = options.ids || inviteEventBodyFactoryDefaultIds;
+  return eventBodyFactory<EnvoyInviteEvent, Config, InvitePayload>({
+    event: options.event,
+    config: options.config,
+    scope: options.scope || [],
+    locationId: options.ids?.location || inviteEventBodyFactoryDefaultIds.location,
+    companyId: options.ids?.company || inviteEventBodyFactoryDefaultIds.company,
+    payload: invitePayloadFactory(options.payloadOptions, ids).build(),
+  });
+}

package/src/factories/metaFactory.ts

@@ -0,0 +1,109 @@
+import { Sync } from 'factory.ts';
+import faker from 'faker';
+import {
+  EnvoyEventMeta,
+  EnvoyMetaAuth,
+  EnvoyMetaCompany,
+  EnvoyMetaJob,
+  EnvoyMetaLocation,
+  EnvoyRouteMeta,
+} from '../sdk/EnvoyMeta';
+import { EnvoyUserAPIScope } from '../sdk/EnvoyUserAPI';
+
+export function jobFactory(name: string): Sync.Factory<EnvoyMetaJob> {
+  return Sync.makeFactory<EnvoyMetaJob>({
+    id: faker.datatype.uuid(),
+    identifier: faker.datatype.string(),
+    name,
+  });
+}
+
+export function locationFactory(id: string): Sync.Factory<EnvoyMetaLocation> {
+  const cityName = faker.address.cityName();
+  const street = faker.address.streetAddress();
+  return Sync.makeFactory<EnvoyMetaLocation>({
+    id,
+    type: 'locations',
+    attributes: {
+      name: cityName,
+      'company-name-override': null,
+      timezone: faker.address.timeZone(),
+      locale: null,
+      address: street,
+      'address-line-one': street,
+      'address-line-two': null,
+      city: cityName,
+      state: faker.address.stateAbbr(),
+      country: faker.address.country(),
+      zip: faker.address.zipCode(),
+      longitude: null,
+      latitude: null,
+      'created-at': faker.date.past().toISOString(),
+    },
+  });
+}
+
+export function companyFactory(id: string): Sync.Factory<EnvoyMetaCompany> {
+  return Sync.makeFactory<EnvoyMetaCompany>({
+    id,
+    type: 'companies',
+    attributes: {
+      name: faker.company.companyName(),
+      active: true,
+      'created-at': faker.date.past().toISOString(),
+    },
+  });
+}
+
+export function authFactory(): Sync.Factory<EnvoyMetaAuth> {
+  return Sync.makeFactory<EnvoyMetaAuth>({
+    token_type: 'Bearer',
+    access_token: faker.random.alphaNumeric(),
+    expires_in: faker.date.future().getSeconds(),
+    refresh_token: null,
+    refresh_token_expires_in: null,
+  });
+}
+
+export function routeMetaFactory<
+  Config extends Record<string, unknown> = Record<string, never>,
+  Params extends Record<string, unknown> = Record<string, never>,
+  >(
+  route: string,
+  config: Partial<Config>,
+  params: Params,
+  scope: Array<EnvoyUserAPIScope>,
+  locationId: string,
+  companyId: string,
+): Sync.Factory<EnvoyRouteMeta> {
+  return Sync.makeFactory<EnvoyRouteMeta>({
+    plugin_id: faker.datatype.uuid(),
+    install_id: Math.ceil(Math.abs(faker.datatype.number())).toString(),
+    location: locationFactory(locationId).build(),
+    company: companyFactory(companyId).build(),
+    auth: scope.length ? authFactory().build() : null,
+    forwarded_bearer_token: faker.random.alphaNumeric(),
+    route,
+    config,
+    params,
+  });
+}
+
+export function eventMetaFactory<Config extends Record<string, unknown> = Record<string, never>>(
+  event: string,
+  config: Partial<Config>,
+  scope: Array<EnvoyUserAPIScope>,
+  locationId: string,
+  companyId: string,
+): Sync.Factory<EnvoyEventMeta> {
+  return Sync.makeFactory<EnvoyEventMeta>({
+    plugin_id: faker.datatype.uuid(),
+    install_id: Math.ceil(Math.abs(faker.datatype.number())).toString(),
+    job: jobFactory(event).build(),
+    location: locationFactory(locationId).build(),
+    company: companyFactory(companyId).build(),
+    auth: scope.length ? authFactory().build() : null,
+    event,
+    config,
+  });
+}

package/src/factories/routeBodyFactory.ts

@@ -0,0 +1,37 @@
+import { EnvoyUserAPIScope } from '../sdk/EnvoyUserAPI';
+import { routeMetaFactory } from './metaFactory';
+
+export const routeBodyFactoryDefaultIds = {
+  locationId: '1',
+  companyId: '1',
+};
+
+export type RouteBodyFactoryOptions<Config, Params, Payload> = {
+  config: Partial<Config>,
+  params: Params,
+  payload: Payload,
+  scope?: Array<EnvoyUserAPIScope>,
+  locationId?: string,
+  companyId?: string,
+  route?: string,
+};
+
+export default function routeBodyFactory<
+  Config extends Record<string, unknown> = Record<string, never>,
+  Params extends Record<string, unknown> = Record<string, never>,
+  Payload extends Record<string, unknown> = Record<string, never>,
+  >(
+  options: RouteBodyFactoryOptions<Config, Params, Payload>,
+) {
+  return {
+    meta: routeMetaFactory<Config, Params>(
+      options.route || '',
+      options.config,
+      options.params,
+      options.scope || [],
+      options.locationId || routeBodyFactoryDefaultIds.locationId,
+      options.companyId || routeBodyFactoryDefaultIds.companyId,
+    ).build(),
+    payload: options.payload,
+  };
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+import './constants';
+
+import EnvoyPluginStoragePipeline from './base/EnvoyPluginStoragePipeline';
+
+import entryEventBodyFactory from './factories/entryEventBodyFactory';
+import eventBodyFactory from './factories/eventBodyFactory';
+import inviteEventBodyFactory from './factories/inviteEventBodyFactory';
+import routeBodyFactory from './factories/routeBodyFactory';
+
+import HttpStatus from './internal/HttpStatus';
+
+import EnvoyPluginJobMock from './mocks/EnvoyPluginJobMock';
+import EnvoyPluginStoragePipelineMock from './mocks/EnvoyPluginStoragePipelineMock';
+
+import EntryPayload from './payloads/EntryPayload';
+import InvitePayload from './payloads/InvitePayload';
+
+import EnvoyMeta from './sdk/EnvoyMeta';
+import EnvoyPluginJob from './sdk/EnvoyPluginJob';
+import EnvoyPluginSDK from './sdk/EnvoyPluginSDK';
+import EnvoyPluginStorage from './sdk/EnvoyPluginStorage';
+import EnvoyRequest from './sdk/EnvoyRequest';
+import EnvoyResponse from './sdk/EnvoyResponse';
+import EnvoyStorageItem from './sdk/EnvoyStorageItem';
+import EnvoyUserAPI from './sdk/EnvoyUserAPI';
+import EnvoyPluginAPI from './sdk/EnvoyPluginAPI';
+
+import EnvoyJWT from './util/EnvoyJWT';
+import EnvoySignatureVerifier from './util/EnvoySignatureVerifier';
+import JSONAPIData from './util/json-api/JSONAPIData';
+
+export * from './factories/entryEventBodyFactory';
+export * from './factories/eventBodyFactory';
+export * from './factories/inviteEventBodyFactory';
+export * from './factories/metaFactory';
+export * from './factories/routeBodyFactory';
+
+export * from './resources/AgreementPageResource';
+export * from './resources/AgreementResource';
+export * from './resources/CompanyResource';
+export * from './resources/CompanyRoleResource';
+export * from './resources/CurrentUserResource';
+export * from './resources/EmployeeResource';
+export * from './resources/FlowResource';
+export * from './resources/InviteResource';
+export * from './resources/LocationResource';
+export * from './resources/LocationRoleResource';
+export * from './resources/SignInFieldPageResource';
+export * from './resources/SignInFieldResource';
+export * from './resources/UserResource';
+
+export * from './sdk/EnvoyMeta';
+export * from './sdk/EnvoyRequest';
+export * from './sdk/EnvoyResponse';
+export * from './sdk/filters';
+export * from './sdk/handlers';
+export * from './sdk/loggers';
+export * from './sdk/middleware';
+
+export * from './util/EnvoySignatureVerifier';
+export * from './util/axiosConstructor';
+
+export {
+  EntryPayload,
+  InvitePayload,
+  EnvoyJWT,
+  EnvoyMeta,
+  EnvoyPluginJob,
+  EnvoyPluginJobMock,
+  EnvoyPluginSDK,
+  EnvoyPluginStorage,
+  EnvoyPluginStoragePipeline,
+  EnvoyPluginStoragePipelineMock,
+  EnvoyRequest,
+  EnvoyResponse,
+  EnvoySignatureVerifier,
+  EnvoyStorageItem,
+  EnvoyPluginAPI,
+  EnvoyUserAPI,
+  JSONAPIData,
+  HttpStatus,
+  entryEventBodyFactory,
+  eventBodyFactory,
+  inviteEventBodyFactory,
+  routeBodyFactory,
+};

package/src/internal/EnvoyEntryEvent.ts

@@ -0,0 +1,10 @@
+type EnvoyEntryEvent =
+  'entry_sign_in' |
+  'entry_sign_out' |
+  'entry_blacklist_review' |
+  'entry_blacklist_deny' |
+  'employee_entry_sign_in' |
+  'employee_entry_sign_out' |
+  string;
+
+export default EnvoyEntryEvent;

package/src/internal/EnvoyInviteEvent.ts

@@ -0,0 +1,13 @@
+type EnvoyInviteEvent =
+  'invite_created' |
+  'invite_updated' |
+  'invite_removed' |
+  'upcoming_visit' |
+  'qr_code_sent' |
+  'employee_invite_created' |
+  'employee_invite_updated' |
+  'employee_invite_removed' |
+  'employee_upcoming_visit' |
+  string;
+
+export default EnvoyInviteEvent;

package/src/internal/EnvoyLocationEvent.ts

@@ -0,0 +1,3 @@
+type EnvoyLocationEvent = 'location_capacity_updated' | string;
+
+export default EnvoyLocationEvent;

package/src/internal/EnvoyOption.ts

@@ -0,0 +1,6 @@
+type EnvoyOption = {
+  label: string,
+  value: string,
+};
+
+export default EnvoyOption;

package/src/internal/EnvoyOptionsRouteParams.ts

@@ -0,0 +1,7 @@
+type EnvoyOptionsRouteParams = {
+  search?: string,
+  page?: number,
+  cursor?: string,
+};
+
+export default EnvoyOptionsRouteParams;

package/src/internal/EnvoyOptionsRouteResponseBody.ts

@@ -0,0 +1,4 @@
+import EnvoyOption from './EnvoyOption';
+
+type EnvoyOptionsRouteResponseBody = Array<EnvoyOption>;
+export default EnvoyOptionsRouteResponseBody;

package/src/internal/EnvoyPluginJobUpdate.ts

@@ -0,0 +1,11 @@
+import EnvoyPluginJobAttachment from '../sdk/EnvoyPluginJobAttachment';
+
+/**
+ * @internal
+ */
+export default interface EnvoyPluginJobUpdate {
+  status?: string,
+  status_message?: string,
+  failure_reason?: string,
+  attachments: Array<EnvoyPluginJobAttachment>,
+}

package/src/internal/EnvoyRemoteValueRouteResponseBody.ts

@@ -0,0 +1,4 @@
+type EnvoyRemoteValueRouteResponseBody = {
+  value: string,
+};
+export default EnvoyRemoteValueRouteResponseBody;

package/src/internal/EnvoySelectedValuesRouteParams.ts

@@ -0,0 +1,5 @@
+type EnvoySelectedValuesRouteParams = {
+  value: Array<string> | string,
+};
+
+export default EnvoySelectedValuesRouteParams;

package/src/internal/EnvoySelectedValuesRouteResponseBody.ts

@@ -0,0 +1,4 @@
+import EnvoyOption from './EnvoyOption';
+
+type EnvoySelectedValuesRouteResponseBody = Array<EnvoyOption> | EnvoyOption | null;
+export default EnvoySelectedValuesRouteResponseBody;

package/src/internal/EnvoyStorageCommand.ts

@@ -0,0 +1,60 @@
+export const UNIQUE_OPTIONS_DEFAULT_CHARS = '0123456789';
+
+export const UNIQUE_OPTIONS_DEFAULT_SIZE = 12;
+
+export const UNIQUE_NUM_OPTIONS_DEFAULT_MIN = 0;
+
+export const UNIQUE_NUM_OPTIONS_DEFAULT_MAX = 9_007_199_254_740_991;
+
+export interface EnvoyStorageSetUniqueOptions {
+  chars?: string,
+  size?: number,
+}
+
+export interface EnvoyStorageSetUniqueNumOptions {
+  min?: number,
+  max?: number,
+}
+
+export interface EnvoyBaseStorageCommand {
+  action: 'get' | 'set' | 'set_unique' | 'set_unique_num' | 'unset',
+  key: string,
+}
+
+export interface EnvoyGetStorageCommand extends EnvoyBaseStorageCommand {
+  action: 'get',
+}
+
+export interface EnvoySetStorageCommand extends EnvoyBaseStorageCommand {
+  action: 'set',
+  value: unknown,
+}
+
+export interface EnvoySetUniqueStorageCommand extends EnvoyBaseStorageCommand, EnvoyStorageSetUniqueOptions {
+  action: 'set_unique',
+}
+
+export interface EnvoySetUniqueNumStorageCommand extends EnvoyBaseStorageCommand, EnvoyStorageSetUniqueNumOptions {
+  action: 'set_unique_num',
+}
+
+export interface EnvoyUnsetStorageCommand extends EnvoyBaseStorageCommand {
+  action: 'unset',
+}
+
+export interface EnvoyListStorageCommand {
+  action: 'list',
+  page: number,
+}
+
+/**
+ * @internal
+ */
+type EnvoyStorageCommand = EnvoyGetStorageCommand
+| EnvoySetStorageCommand
+| EnvoySetUniqueStorageCommand
+| EnvoySetUniqueNumStorageCommand
+| EnvoyUnsetStorageCommand
+| EnvoyListStorageCommand;
+
+export default EnvoyStorageCommand;

package/src/internal/EnvoyStorageResult.ts

@@ -0,0 +1,5 @@
+import EnvoyStorageItem from '../sdk/EnvoyStorageItem';
+
+type EnvoyStorageResult<Value = unknown> = EnvoyStorageItem<Value> | Array<EnvoyStorageItem<Value>> | null;
+
+export default EnvoyStorageResult;

package/src/internal/HttpStatus.ts

@@ -0,0 +1,12 @@
+/**
+ * Use these status codes to inform Envoy of a job's or route's status.
+ *
+ * @internal
+ */
+enum HttpStatus {
+  ONGOING = 202,
+  IGNORED = 400,
+  FAILED = 412,
+  UNEXPECTED_FAILURE = 500,
+}
+export default HttpStatus;