@friggframework/core 0.2.31-v1-alpha.6 → 1.0.1-v1-alpha-package-update.0

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;
+}

package/types/module-plugin/index.d.ts

@@ -0,0 +1,293 @@
+declare module "@friggframework/module-plugin" {
+  import { Model } from "mongoose";
+  import { Delegate, IFriggDelegate } from "@friggframework/core";
+
+  export class Credential extends Model {
+    userId: string;
+    auth_is_valid: boolean;
+    subType: string;
+    externalId: string;
+  }
+
+  export class EntityManager implements IFriggEntityManager {
+    static primaryEntityClass: any;
+    static entityManagerClasses: any[];
+    static entityTypes: string[];
+    static getEntitiesForUser(userId: string): Promise<any[]>;
+    static checkIsValidType(entityType: string): boolean;
+    static getEntityManagerClass(entityType?: string): any;
+
+    static getEntityManagerInstanceFromEntityId(
+      entityId: string,
+      userId: string
+    ): Promise<any>;
+  }
+
+  interface IFriggEntityManager {}
+
+  export class Entity extends Model {
+    credentialId: string;
+    subType: string;
+    userId: string;
+    name: string;
+    externalId: string;
+  }
+
+  export type MappedEntity = Entity & { id: string; type: any };
+  export class ModuleManager extends Delegate implements IFriggModuleManager {
+    static Entity: Entity;
+    static Credential: Credential;
+
+    constructor(params: { userId: string });
+
+    static getName(): any;
+    static getInstance(params: any): Promise<any>;
+    static getEntitiesForUserId(userId: string): Promise<MappedEntity[]>;
+
+    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    findOrCreateEntity(params: any): Promise<any>;
+    getAllSyncObjects(SyncClass: any): Promise<any>;
+    getAuthorizationRequirements(params: any): Promise<any>;
+    getEntityId(): Promise<string>;
+    getEntityOptions(): Promise<any>;
+    markCredentialsInvalid(): Promise<Credential>;
+    processAuthorizationCallback(params: any): Promise<any>;
+    testAuth(params: any): Promise<any>;
+    validateAuthorizationRequirements(): Promise<boolean>;
+  }
+
+  interface IFriggModuleManager extends IFriggDelegate {
+    getEntityId(): Promise<string>;
+    validateAuthorizationRequirements(): Promise<boolean>;
+    getAuthorizationRequirements(params: any): Promise<any>;
+    testAuth(params: any): Promise<any>;
+    processAuthorizationCallback(params: any): Promise<any>;
+    getEntityOptions(): Promise<any>;
+    findOrCreateEntity(params: any): Promise<any>;
+    getAllSyncObjects(SyncClass: any): Promise<any>;
+    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    markCredentialsInvalid(): Promise<Credential>;
+  }
+
+  export class Requester implements IFriggRequester {
+    DLGT_INVALID_AUTH: string;
+    backOff: number[];
+    fetch: any;
+    isRefreshable: boolean;
+    refreshCount: number;
+
+    _delete(options: RequestOptions): Promise<any>;
+    _get(options: RequestOptions): Promise<any>;
+    _patch(options: RequestOptions): Promise<any>;
+    _post(options: RequestOptions, stringify?: boolean): Promise<any>;
+    _put(options: RequestOptions): Promise<any>;
+    _request(
+      url: string,
+      options: Omit<RequestOptions, "url">,
+      i?: number
+    ): Promise<any>;
+    parseBody(response: any): Promise<any>;
+    refreshAuth(): Promise<any>;
+
+    delegate: any;
+    delegateTypes: any[];
+
+    notify(delegateString: string, object?: any): Promise<any>;
+    receiveNotification(
+      notifier: any,
+      delegateString: string,
+      object?: any
+    ): Promise<any>;
+  }
+
+  interface IFriggRequester extends IFriggDelegate {
+    backOff: number[];
+    isRefreshable: boolean;
+    refreshCount: number;
+    DLGT_INVALID_AUTH: string;
+    fetch: any;
+
+    parseBody(response: any): Promise<any>;
+    _request(
+      url: string,
+      options: Omit<RequestOptions, "url">,
+      i?: number
+    ): Promise<any>;
+    _get(options: RequestOptions): Promise<any>;
+    _post(options: RequestOptions, stringify?: boolean): Promise<any>;
+    _patch(options: RequestOptions): Promise<any>;
+    _put(options: RequestOptions): Promise<any>;
+    _delete(options: RequestOptions): Promise<any>;
+    refreshAuth(): Promise<any>;
+  }
+
+  type RequestOptions = {
+    url: string;
+    headers?: object;
+    query?: object;
+    returnFullRes?: boolean;
+    body?: any;
+  };
+
+  type RequesterConstructor = {
+    backOff?: number[];
+    fetch?: any;
+  };
+
+  export class ApiKeyRequester
+    extends Requester
+    implements IFriggApiKeyRequester
+  {
+    API_KEY_NAME: string;
+    API_KEY_VALUE: any;
+
+    constructor(params: RequesterConstructor);
+    addAuthHeaders(headers: object): Promise<object>;
+    isAuthenticated(): boolean;
+    setApiKey(api_key: any): void;
+  }
+
+  interface IFriggApiKeyRequester extends IFriggRequester {
+    API_KEY_NAME: string;
+    API_KEY_VALUE: string;
+
+    addAuthHeaders(headers: object): Promise<object>;
+    isAuthenticated(): boolean;
+    setApiKey(api_key: string): void;
+  }
+
+  export class BasicAuthRequester
+    extends Requester
+    implements IFriggBasicAuthRequester
+  {
+    password: string;
+    username: string;
+
+    constructor(params: BasicAuthRequesterConstructor);
+    addAuthHeaders(headers: object): Promise<object>;
+    isAuthenticated(): boolean;
+    setPassword(password: string): void;
+    setUsername(username: string): void;
+  }
+
+  interface IFriggBasicAuthRequester extends IFriggRequester {
+    username: string;
+    password: string;
+
+    addAuthHeaders(headers: object): Promise<object>;
+    isAuthenticated(): boolean;
+    setUsername(username: string): void;
+    setPassword(password: string): void;
+  }
+
+  type BasicAuthRequesterConstructor = RequesterConstructor & {
+    username?: string;
+    password?: string;
+  };
+
+  export class OAuth2Requester
+    extends Requester
+    implements IFriggOAuth2Requester
+  {
+    DLGT_TOKEN_DEAUTHORIZED: string;
+    DLGT_TOKEN_UPDATE: string;
+    accessTokenExpire: any;
+    access_token: string;
+    audience: any;
+    authorizationUri: any;
+    baseURL: string;
+    client_id: string;
+    client_secret: string;
+    grant_type: string;
+    password: string;
+    redirect_uri: string;
+    refreshTokenExpire: any;
+    refresh_token: string;
+    scope: string;
+    state: any;
+    username: string;
+
+    constructor(params: OAuth2RequesterConstructor);
+
+    addAuthHeaders(headers: object): Promise<object>;
+    getAuthorizationUri(): string;
+    getTokenFromClientCredentials(): Promise<Token>;
+    getTokenFromCode(code: string): Promise<Token>;
+    getTokenFromCodeBasicAuthHeader(code: string): Promise<Token>;
+    getTokenFromUsernamePassword(): Promise<Token>;
+    isAuthenticated(): boolean;
+    refreshAccessToken(refreshTokenObject: {
+      refresh_token: string;
+    }): Promise<Token>;
+    setTokens(params: Token): Promise<void>;
+  }
+  interface IFriggOAuth2Requester extends IFriggRequester {
+    DLGT_TOKEN_UPDATE: string;
+    DLGT_TOKEN_DEAUTHORIZED: string;
+
+    grant_type?: string;
+    client_id?: string;
+    client_secret?: string;
+    redirect_uri?: string;
+    scope?: string;
+    authorizationUri?: any;
+    baseURL?: string;
+    access_token?: string;
+    refresh_token?: string;
+    accessTokenExpire?: any;
+    refreshTokenExpire?: any;
+    audience?: any;
+    username?: string;
+    password?: string;
+    state?: any;
+
+    setTokens(params: Token): Promise<void>;
+    getAuthorizationUri(): string;
+    getTokenFromCode(code: string): Promise<Token>;
+    getTokenFromCodeBasicAuthHeader(code: string): Promise<Token>;
+    refreshAccessToken(refreshTokenObject: {
+      refresh_token: string;
+    }): Promise<Token>;
+    addAuthHeaders(headers: object): Promise<object>;
+    isAuthenticated(): boolean;
+    refreshAuth(): Promise<void>;
+    getTokenFromUsernamePassword(): Promise<Token>;
+    getTokenFromClientCredentials(): Promise<Token>;
+  }
+
+  type Token = {
+    access_token?: string;
+    refresh_token?: string;
+    expires_in: any;
+    x_refresh_token_expires_in: any;
+  };
+
+  type OAuth2RequesterConstructor = {
+    grant_type?: string;
+    client_id?: string;
+    client_secret?: string;
+    redirect_uri?: string;
+    scope?: string;
+    authorizationUri?: any;
+    baseURL?: string;
+    access_token?: string;
+    refresh_token?: string;
+    accessTokenExpire?: any;
+    refreshTokenExpire?: any;
+    audience?: any;
+    username?: string;
+    password?: string;
+    state?: any;
+  };
+
+  export const ModuleConstants: {
+    authType: {
+      oauth2: "oauth2";
+      oauth1: "oauth1";
+      basic: "basic";
+      apiKey: "apiKey";
+    };
+  };
+}

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

@@ -0,0 +1,6 @@
+declare module "@friggframework/prettier-config" {
+  export const semi: true;
+  export const tabWidth = 4;
+  export const singleQuote = true;
+  export const useTabs: false;
+}