@friggframework/core 0.2.31-v1-alpha.6 → 1.0.1-canary.278.7b20420.0

package/types/README.md

@@ -0,0 +1,24 @@
+# types
+
+This package exports the `types` used in [Frigg](https://friggframework.org) packages.
+
+
+### Get Started
+Install the package with `npm` or `yarn`:
+
+```bash
+npm install @friggframework/types
+```
+or
+```bash
+yarn add @friggframework/types
+```
+
+Make sure to reference the types in your `tsconfig.json`
+
+```json
+"typeRoots": [
+    "./node_modules/@types",
+    "./node_modules/@friggframework/types"
+]
+```

package/types/assertions/index.d.ts

@@ -0,0 +1,83 @@
+declare module "@friggframework/assertions" {
+  type TypeOfType =
+    | "undefined"
+    | "object"
+    | "boolean"
+    | "number"
+    | "string"
+    | "function"
+    | "symbol"
+    | "bigint";
+
+  export function get<TObject extends object, TKey extends string, TDefault>(
+    object: TObject,
+    key: TKey | undefined,
+    defaultValue: Exclude<TDefault, undefined>
+  ): TKey extends keyof TObject ? TObject[TKey] : TDefault;
+
+  export function get<TObject extends object, TKey extends keyof TObject>(
+    object: TObject,
+    key: TKey
+  ): TObject[TKey];
+
+  export function getAll<TObject extends object, TKey extends keyof TObject>(
+    object: TObject,
+    requiredKeys: TKey[]
+  ): Partial<TObject>;
+
+  export function verifyType(value: unknown, paramType: TypeOfType): void;
+
+  export function getParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends string,
+    TKeyType extends TypeOfType,
+    TDefault
+  >(
+    params: TObject,
+    key: TKey,
+    type: TKeyType,
+    defaultValue: TDefault
+  ): TDefault;
+
+  export function getParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TKeyType extends TypeOfType
+  >(params: TObject, key: TKey, type: TKeyType): TObject[TKey];
+
+  export function getArrayParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends string,
+    TKeyType extends TypeOfType,
+    TDefault
+  >(
+    params: TObject,
+    key: TKey,
+    type: TKeyType,
+    defaultValue: TDefault
+  ): TDefault;
+
+  export function getArrayParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TKeyType extends TypeOfType
+  >(params: TObject, key: TKey, type: TKeyType): TObject[TKey];
+
+  export function getAndVerifyType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TClassType extends unknown
+  >(object: TObject, key: TKey, classType: TClassType): TObject[TKey];
+
+  export function getAndVerifyType<
+    TObject extends object,
+    TKey extends string,
+    TClassType extends unknown,
+    TDefault
+  >(
+    object: TObject,
+    key: TKey,
+    classType: TClassType,
+    defaultValue: TDefault
+  ): TKey extends keyof TObject ? TObject[TKey] : TDefault;
+}

package/types/associations/index.d.ts

@@ -0,0 +1,74 @@
+declare module "@friggframework/associations/model" {
+  import { Model } from "mongoose";
+
+  export class Association extends Model {
+    integrationId: string;
+    name: string;
+    type: string;
+    primaryObject: string;
+    objects: {
+      entityId: string;
+      objectType: string;
+      objId: string;
+      metadata?: object;
+    }[];
+  }
+}
+
+declare module "@friggframework/associations/association" {
+  export default class Association implements IFriggAssociation {
+    data: any;
+    dataIdentifier: any;
+    dataIdentifierHash: string;
+    matchHash: string;
+    moduleName: any;
+    syncId: any;
+
+    static Config: {
+      name: "Association";
+      reverseModuleMap: {};
+    };
+
+    constructor(params: AssociationConstructor);
+
+    dataKeyIsReplaceable(key: string): boolean;
+
+    equals(syncObj: any): boolean;
+
+    getHashData(): string;
+
+    getName(): any;
+
+    hashJSON(data: any): string;
+
+    isModuleInMap(moduleName: any): any;
+
+    reverseModuleMap(moduleName: any): any;
+
+    setSyncId(syncId: string): any;
+  }
+
+  interface IFriggAssociation {
+    data: any;
+    moduleName: any;
+    dataIdentifier: any;
+    dataIdentifierHash: string;
+    matchHash: string;
+    syncId: any;
+
+    equals(syncObj: any): boolean;
+    dataKeyIsReplaceable(key: string): boolean;
+    isModuleInMap(moduleName: any): any;
+    getName(): any;
+    getHashData(): string;
+    setSyncId(syncId: string): any;
+    reverseModuleMap(moduleName: any): any;
+    hashJSON(data: any): string;
+  }
+
+  type AssociationConstructor = {
+    data: any;
+    moduleName: any;
+    dataIdentifier: any;
+  };
+}

package/types/core/index.d.ts

@@ -0,0 +1,54 @@
+declare module "@friggframework/core" {
+  import { SQS } from "aws-sdk";
+
+  export class Delegate implements IFriggDelegate {
+    delegate: any;
+    delegateTypes: any[];
+
+    constructor(params: Record<string, unknown> & { delegate?: unknown });
+    notify(delegateString: string, object?: any): Promise<any>;
+    receiveNotification(
+      notifier: any,
+      delegateString: string,
+      object?: any
+    ): Promise<any>;
+  }
+
+  interface IFriggDelegate {
+    delegate: any;
+    delegateTypes: any[];
+
+    notify(delegateString: string, object?: any): Promise<any>;
+    receiveNotification(
+      notifier: any,
+      delegateString: string,
+      object?: any
+    ): Promise<any>;
+  }
+
+  export class Worker implements IWorker {
+    getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
+
+    run(params: { Records: any }): Promise<void>;
+
+    send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
+
+    sendAsyncSQSMessage(params: SendSQSMessageParams): Promise<string>;
+  }
+
+  interface IWorker {
+    getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
+    run(params: { Records: any }): Promise<void>;
+    send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
+    sendAsyncSQSMessage(params: SendSQSMessageParams): Promise<string>;
+  }
+
+  export function loadInstalledModules(): any[];
+
+  type GetQueueURLParams = {
+    QueueName: string;
+    QueueOwnerAWSAccountId?: string;
+  };
+
+  type SendSQSMessageParams = SQS.SendMessageRequest;
+}

package/types/database/index.d.ts

@@ -0,0 +1,3 @@
+declare module "@friggframework/database/mongo" {
+  export function connectToDatabase(): Promise<void>;
+}

package/types/encrypt/index.d.ts

@@ -0,0 +1,5 @@
+declare module "@friggframework/encrypt" {
+  import { Schema } from "mongoose";
+
+  export function Encrypt(schema: Schema, options: any): void;
+}

package/types/errors/index.d.ts

@@ -0,0 +1,66 @@
+declare module "@friggframework/errors" {
+  export class BaseError extends Error {
+    constructor(message?: string, options?: ErrorOptions, ...otherOptions: any);
+  }
+
+  export class FetchError extends BaseError {
+    constructor(options?: FetchErrorConstructor);
+
+    static create(options?: CreateFetchErrorParams): Promise<FetchError>;
+  }
+
+  type FetchErrorConstructor = {
+    resource?: string;
+    init?: Partial<{
+      method: string;
+      credentials: string;
+      headers: object;
+      query: object;
+      body: URLSearchParams | any;
+      returnFullRes: false;
+    }>;
+    response?: {
+      headers?: object;
+      status?: number;
+      statusText?: string;
+      text?: () => Promise<string>;
+    };
+    responseBody?: any;
+  };
+
+  type CreateFetchErrorParams = Omit<FetchErrorConstructor, "responseBody"> & {
+    body: any;
+  };
+
+  export class HaltError extends BaseError {
+    isHaltError: boolean;
+  }
+
+  export class RequiredPropertyError extends BaseError {
+    constructor(
+      options: RequiredPropertyErrorOptions,
+      otherOptions?: ErrorOptions
+    );
+  }
+
+  type RequiredPropertyErrorOptions = {
+    parent?: new () => Class;
+    key: string;
+  };
+
+  export class ParameterTypeError extends BaseError {
+    constructor(
+      options: ParameterTypeErrorOptions,
+      otherOptions?: ErrorOptions
+    );
+  }
+
+  type ParameterTypeErrorOptions = {
+    parent?: new () => Class;
+    key: string;
+    value: string;
+    expectedType: new () => Class;
+  };
+
+  type Class<T = any> = new (...args: any[]) => T;
+}

package/types/eslint-config/index.d.ts

@@ -0,0 +1,41 @@
+declare module "@friggframework/eslint-config" {
+  const config: {
+    env: {
+      commonjs: true,
+      es2020: true,
+      jest: true,
+    },
+    extends: ["prettier", "plugin:markdown/recommended"],
+    parser: "@babel/eslint-parser",
+    parserOptions: {
+      ecmaVersion: 11,
+      requireConfigFile: false,
+    },
+    plugins: ["no-only-tests"],
+    ignorePatterns: ["coverage/", ".nyc_output/"],
+    overrides: [
+      {
+        files: ["*.json"],
+        plugins: ["json"],
+        extends: ["plugin:json/recommended"],
+      },
+      {
+        files: ["*.yaml", "*.yml"],
+        plugins: ["yaml"],
+        extends: ["plugin:yaml/recommended"],
+      },
+    ],
+    rules: {
+      "no-only-tests/no-only-tests": ["error", { fix: false }],
+      "no-unused-vars": [
+        "warn",
+        { vars: "all", args: "after-used", ignoreRestSiblings: false },
+      ],
+      "no-console": ["warn"],
+      camelcase: ["warn"],
+      "no-mixed-requires": ["warn"],
+      "no-warning-comments": ["warn"],
+    },
+  };
+  export default config;
+}

package/types/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference path="./assertions/index.d.ts" />
+/// <reference path="./core/index.d.ts" />
+/// <reference path="./integrations/index.d.ts" />
+/// <reference path="./encrypt/index.d.ts" />
+/// <reference path="./errors/index.d.ts" />
+/// <reference path="./module-plugin/index.d.ts" />
+/// <reference path="./database/index.d.ts" />
+/// <reference path="./lambda/index.d.ts" />
+/// <reference path="./logs/index.d.ts" />
+/// <reference path="./test-environment/index.d.ts" />
+/// <reference path="./prettier-config/index.d.ts" />
+/// <reference path="./eslint-config/index.d.ts" />
+/// <reference path="./associations/index.d.ts" />
+/// <reference path="./syncs/index.d.ts" />

package/types/integrations/index.d.ts

@@ -0,0 +1,191 @@
+declare module "@friggframework/integrations" {
+  import { Delegate, IFriggDelegate } from "@friggframework/core";
+  import { Model } from "mongoose";
+  import { EntityManager } from "@friggframework/module-plugin";
+
+  export class Integration extends Model {
+    entities: any[];
+    userId: string;
+    status: string; // IntegrationStatus
+    config: any;
+    version: string;
+    messages: {
+      errors: [];
+      warnings: [];
+      info: [];
+      logs: [];
+    };
+  }
+
+  export class IntegrationManager
+    extends Delegate
+    implements IFriggIntegrationManager
+  {
+    integration: Integration;
+    primaryInstance: any;
+    targetInstance: any;
+
+    static Config: {
+      name: string;
+      version: string;
+      supportedVersions: string[];
+      events: string[];
+    };
+    static integrationManagerClasses: any[];
+    static integrationTypes: string[];
+
+    constructor(params: any);
+
+    static getInstanceFromIntegrationId(params: {
+      integrationId: string;
+      userId?: string;
+    }): Promise<any>;
+    static getName(): string;
+    static getCurrentVersion(): string;
+
+    validateConfig(): Promise<void>;
+    testAuth(): Promise<void>;
+
+    static getInstance(params: {
+      userId: string;
+      integrationId: string;
+    }): Promise<IntegrationManager>;
+    static getIntegrationManagerClasses(type: string): any[];
+
+    static createIntegration(
+      entities: { id: string; user: any },
+      userId: string,
+      config: any,
+      EntityManager: EntityManager
+    ): Promise<any>;
+
+    static getFormattedIntegration(
+      integration: Integration
+    ): Promise<FormattedIntegration[]>;
+    static getIntegrationsForUserId(
+      userId: string
+    ): Promise<FormattedIntegration[]>;
+    static getIntegrationForUserById(
+      userId: string,
+      integrationId: string
+    ): Promise<Integration>;
+    static deleteIntegrationForUserById(
+      userId: string,
+      integrationId: string
+    ): Promise<void>;
+    static getIntegrationById(id: string): Promise<Integration>;
+    static getFilteredIntegrationsForUserId(
+      userId: string,
+      filter: any
+    ): Promise<Integration[]>;
+    static getCredentialById(credential_id: string): Promise<any>;
+    static listCredentials(options: any): Promise<any>;
+    static getEntityById(entity_id: any): Promise<any>;
+    static listEntities(options: any): Promise<any>;
+
+    processCreate(params: any): Promise<any>;
+    processUpdate(params: any): Promise<any>;
+    processDelete(params: any): Promise<any>;
+
+    getConfigOptions(): Promise<any>;
+    getSampleData(): Promise<any>;
+  }
+
+  type FormattedIntegration = {
+    entities: any[];
+    messages: any;
+    id: any;
+    config: any;
+    version: any;
+    status: any;
+  };
+
+  interface IFriggIntegrationManager extends IFriggDelegate {
+    primaryInstance: any; //  Returns the Freshbooks manager instance
+    targetInstance: any; // Returns a manager e.g. StripeManager instance containing the entitiy, credential, api etc
+    integration: Integration; // Integration model instance
+
+    validateConfig(): Promise<void>;
+    testAuth(): Promise<void>;
+    processCreate(params: any): Promise<any>;
+    processUpdate(params: any): Promise<any>;
+    processDelete(params: any): Promise<any>;
+
+    getConfigOptions(): Promise<any>;
+    getSampleData(): Promise<any>;
+  }
+
+  export class IntegrationConfigManager
+    implements IFriggIntegrationConfigManager
+  {
+    options: IntegrationOptions[];
+    primary: any;
+
+    getIntegrationOptions(): Promise<GetIntegrationOptions>;
+  }
+
+  interface IFriggIntegrationConfigManager {
+    options: IntegrationOptions[];
+    primary: any;
+
+    getIntegrationOptions(): Promise<GetIntegrationOptions>;
+  }
+
+  type GetIntegrationOptions = {
+    entities: {
+      primary: any;
+      options: any[];
+      autorized: any[];
+    };
+    integrations: any[];
+  };
+
+  export class Options implements IFriggIntegrationOptions {
+    display: IntegrationOptionDisplay;
+    hasUserConfig: boolean;
+    isMany: boolean;
+    module: any;
+    requiresNewEntity: boolean;
+    type: string;
+
+    constructor(params: {
+      display: Partial<IntegrationOptionDisplay>;
+      type?: string;
+      hasUserConfig?: boolean;
+      isMany?: boolean;
+      requiresNewEntity?: boolean;
+      module?: any;
+    });
+    get(): IntegrationOptions;
+  }
+
+  interface IFriggIntegrationOptions {
+    module: any;
+    type: string;
+    hasUserConfig: boolean;
+    isMany: boolean;
+    requiresNewEntity: boolean;
+    display: IntegrationOptionDisplay;
+
+    get(): IntegrationOptions;
+  }
+
+  type IntegrationOptions = {
+    type: string;
+    hasUserConfig: boolean;
+    isMany: boolean;
+    requiresNewEntity: boolean;
+    display: IntegrationOptionDisplay;
+  };
+
+  type IntegrationOptionDisplay = {
+    name: string;
+    description: string;
+    detailsUrl: string;
+    icon: string;
+  };
+
+  interface IFriggIntegrationsPackage {
+    IntegrationManager: IFriggIntegrationManager;
+  }
+}

package/types/lambda/index.d.ts

@@ -0,0 +1,31 @@
+declare module "@friggframework/lambda/TimeoutCatcher" {
+  export class TimeoutCatcher implements IFriggTimeoutCatcher {
+    isFinished: boolean;
+    waitTime: number;
+
+    constructor(params: TimeoutCatcherConstructor);
+    work(): Promise<any>;
+    cleanUp(): Promise<any>;
+    doWork(): Promise<void>;
+    exitBeforeTimeout(): Promise<void>;
+    watch(): Promise<boolean>;
+  }
+
+  interface IFriggTimeoutCatcher {
+    isFinished: boolean;
+    work: () => Promise<any>;
+    cleanUp: () => Promise<any>;
+    waitTime: number;
+
+    watch(): Promise<boolean>;
+    doWork(): Promise<void>;
+    exitBeforeTimeout(): Promise<void>;
+  }
+
+  type TimeoutCatcherConstructor = {
+    work: () => Promise<any>;
+    timeout: number;
+    cleanUp?: () => Promise<any>;
+    cleanUpTime?: number;
+  };
+}

package/types/logs/index.d.ts

@@ -0,0 +1,5 @@
+declare module "@friggframework/logs/logger" {
+  export function debug(...messages: any[]): void;
+  export function initDebugLog(...initMessages: any[]): void;
+  export function flushDebugLog(error: any): void;
+}