@coast/service-common 1.0.5 → 1.0.6

package/dist/models/coast-api/CoastApiRequests.d.ts

@@ -0,0 +1,70 @@
+import { SamlUser } from '@coast/core-api-types/auth/SamlUser';
+import { Card } from '@coast/core-api-types/card/Card';
+import { UpdateCard } from '@coast/core-api-types/card/UpdateCard';
+import { Channel } from '@coast/core-api-types/channel/Channel';
+import { ListEntitiesFormData } from '@coast/core-api-types/export/ListEntitiesFormData';
+import { ListEntitiesFormDataResult } from '@coast/core-api-types/export/ListEntitiesFormDataResult';
+import { CreateUserV2 } from '@coast/core-api-types/user/CreateUserV2';
+import { UpdateUser } from '@coast/core-api-types/user/UpdateUser';
+import { User } from '@coast/core-api-types/user/User';
+import { CreateWorkflowAutomationEvent } from '@coast/core-api-types/workflow-automation/CreateWorkflowAutomationEvent';
+import { AggregateNumberStats } from '@coast/core-api-types/workflow-template/entities/AggregateNumberStats';
+import { AggregateRelatedCardQuantity } from '@coast/core-api-types/workflow-template/entities/AggregateRelatedCardQuantity';
+import { CreateEntityAuditTrailEvent } from '@coast/core-api-types/workflow-template/entities/audit-trail/CreateEntityAuditTrailEvent';
+import { EntityAuditTrailEvent } from '@coast/core-api-types/workflow-template/entities/audit-trail/EntityAuditTrailEvent';
+import { CreateWorkflowEntity } from '@coast/core-api-types/workflow-template/entities/CreateWorkflowEntity';
+import { GetWorkflowEntityResult } from '@coast/core-api-types/workflow-template/entities/GetWorkflowEntityResult';
+import { UpdateWorkflowEntity } from '@coast/core-api-types/workflow-template/entities/UpdateWorkflowEntity';
+import { UpdateWorkflowTemplate } from '@coast/core-api-types/workflow-template/UpdateWorkflowTemplate';
+import { WorkflowTemplate } from '@coast/core-api-types/workflow-template/WorkflowTemplate';
+import { GqlRequestBody } from '../../modules/utils/graphql/GqlRequestBody';
+export declare class CoastApiRequests {
+    static aggregateRelatedCardQuantityStats(filter: AggregateRelatedCardQuantity): GqlRequestBody<AggregateRelatedCardQuantity, {
+        aggregateRelatedCardQuantityStats: AggregateNumberStats;
+    }>;
+    static createEntityAuditTrailEvent(createEntityAuditTrailEvent: CreateEntityAuditTrailEvent): GqlRequestBody<CreateEntityAuditTrailEvent, {
+        createEntityAuditTrailEvent: EntityAuditTrailEvent;
+    }>;
+    static createUsers(createUsers: CreateUserV2[]): GqlRequestBody<CreateUserV2[], {
+        createUserV2: User[];
+    }>;
+    static createWorkflowAutomationEvent(createWorkflowAutomationEvent: CreateWorkflowAutomationEvent): GqlRequestBody<CreateWorkflowAutomationEvent, {
+        createWorkflowAutomationEvent: boolean;
+    }>;
+    static createWorkflowEntity(createWorkflowEntity: CreateWorkflowEntity): GqlRequestBody<CreateWorkflowEntity, {
+        createWorkflowEntity: GetWorkflowEntityResult;
+    }>;
+    static getCard(cardId: string): GqlRequestBody<string, {
+        getCard: Card;
+    }>;
+    static getChannel(channelId: number): GqlRequestBody<number, {
+        getChannel: Channel;
+    }>;
+    static getSamlUser(email: string, samlOrganizationId: string): GqlRequestBody<{
+        email: string;
+        samlOrganizationId: string;
+    }, {
+        getSamlUser: SamlUser;
+    }>;
+    static getWorkflowEntity(workflowEntityId: string): GqlRequestBody<string, {
+        getWorkflowEntity: GetWorkflowEntityResult;
+    }>;
+    static getWorkflowTemplate(workflowTemplateId: string): GqlRequestBody<string, {
+        getWorkflowTemplate: WorkflowTemplate;
+    }>;
+    static listWorkflowEntitiesFormData(filter: ListEntitiesFormData): GqlRequestBody<ListEntitiesFormData, {
+        listEntitiesFormData: ListEntitiesFormDataResult;
+    }>;
+    static updateCard(card: UpdateCard): GqlRequestBody<UpdateCard, {
+        updateCard: Card;
+    }>;
+    static updateUser(updateUser: UpdateUser): GqlRequestBody<UpdateUser, {
+        updateUserV2: User;
+    }>;
+    static updateWorkflowEntity(updateWorkflowEntity: UpdateWorkflowEntity): GqlRequestBody<UpdateWorkflowEntity, {
+        updateWorkflowEntity: GetWorkflowEntityResult;
+    }>;
+    static updateWorkflowTemplate(updateWorkflowTemplate: UpdateWorkflowTemplate): GqlRequestBody<UpdateWorkflowTemplate, {
+        updateWorkflowTemplate: WorkflowTemplate;
+    }>;
+}

package/dist/models/coast-api/CoastApiRequests.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoastApiRequests = void 0;
+const WorkflowEntityGqlFields_1 = require("./WorkflowEntityGqlFields");
+const WorkflowTemplateGqlFields_1 = require("./WorkflowTemplateGqlFields");
+class CoastApiRequests {
+    static aggregateRelatedCardQuantityStats(filter) {
+        return {
+            query: `
+                query ($input: AggregateRelatedCardQuantity!) {
+                    aggregateRelatedCardQuantityStats(input: $input)
+                }
+            `,
+            variables: { input: filter },
+        };
+    }
+    static createEntityAuditTrailEvent(createEntityAuditTrailEvent) {
+        return {
+            query: `
+                mutation ($input: CreateEntityAuditTrailEvent!) {
+                    createEntityAuditTrailEvent(input: $input) { id }
+                }
+            `,
+            variables: { input: createEntityAuditTrailEvent },
+        };
+    }
+    static createUsers(createUsers) {
+        return {
+            query: `
+                mutation ($input: [CreateUserV2!]!) {
+                    createUsersV2(input: $input) {
+                        id
+                        firstName
+                        lastName
+                        email
+                        phoneNumber
+                        role
+                        createdAt
+                        updatedAt
+                    }
+                }
+            `,
+            variables: { input: createUsers },
+        };
+    }
+    static createWorkflowAutomationEvent(createWorkflowAutomationEvent) {
+        return {
+            query: `
+                mutation ($input: CreateWorkflowAutomationEvent!) {
+                    createWorkflowAutomationEvent(input: $input)
+                }
+            `,
+            variables: { input: createWorkflowAutomationEvent },
+        };
+    }
+    static createWorkflowEntity(createWorkflowEntity) {
+        return {
+            query: `
+                mutation ($input: CreateWorkflowEntity!) {
+                    createWorkflowEntity(input: $input) {
+                        entity {
+                            id
+                            workflowTemplateId
+                            fields
+                        }
+                        refs {
+                            workflowEntityRefs {
+                                id
+                            }
+                            personRefs {
+                                id
+                            }
+                            workflowTemplateRefs {
+                                id
+                            }
+                        }
+                    }
+                }
+            `,
+            variables: { input: createWorkflowEntity },
+        };
+    }
+    static getCard(cardId) {
+        return {
+            query: `
+                query ($id: UUID!) {
+                    getCard(id: $id) {
+                        id
+                        fields
+                    }
+                }
+            `,
+            variables: { id: cardId },
+        };
+    }
+    static getChannel(channelId) {
+        return {
+            query: `
+                query ($id: Int!) {
+                    getChannel(id: $id) {
+                        id
+                        name
+                        slug
+                    }
+                }
+            `,
+            variables: { id: channelId },
+        };
+    }
+    static getSamlUser(email, samlOrganizationId) {
+        return {
+            query: `
+                query ($input: GetSamlUser!) {
+                    getSamlUser(input: $input) {
+                        id
+                        email
+                        businessId
+                    }
+                }
+            `,
+            variables: { input: { email, samlOrganizationId } },
+        };
+    }
+    static getWorkflowEntity(workflowEntityId) {
+        return {
+            query: `
+                query ($id: UUID!) {
+                    getWorkflowEntity(id: $id) {
+                        ${WorkflowEntityGqlFields_1.WorkflowEntityGqlFields.fields}
+                    }
+                }
+            `,
+            variables: { id: workflowEntityId },
+        };
+    }
+    static getWorkflowTemplate(workflowTemplateId) {
+        return {
+            query: `
+                query ($id: UUID!) {
+                    getWorkflowTemplate(id: $id) {
+                        components {
+                            ${WorkflowTemplateGqlFields_1.WorkflowTemplateGqlFields.componentFields}
+                        }
+                    }
+                }
+            `,
+            variables: { id: workflowTemplateId },
+        };
+    }
+    static listWorkflowEntitiesFormData(filter) {
+        return {
+            query: `
+                query ($input: ListEntitiesFormData!) {
+                    listEntitiesFormData(input: $input) {
+                        hasMore 
+                        totalResults 
+                        exports { 
+                            type 
+                            title 
+                            targetFormat 
+                            data {
+                                ... on ComponentDataExport {
+                                    label 
+                                    value 
+                                    imageUrls 
+                                    type
+                                }
+                                ... on SubformDataExport {
+                                    type
+                                    title
+                                    businessName
+                                    data {
+                                        ... on ComponentDataExport {
+                                            label 
+                                            value 
+                                            imageUrls 
+                                            type
+                                        }
+                                    }
+                                }
+                            } 
+                            businessName 
+                            url 
+                        } 
+                    }
+                }
+            `,
+            variables: { input: filter },
+        };
+    }
+    static updateCard(card) {
+        return {
+            query: `
+                mutation ($input: UpdateCard!) {
+                    updateCard(input: $input) {
+                        id
+                    }
+                }
+            `,
+            variables: { input: card },
+        };
+    }
+    static updateUser(updateUser) {
+        return {
+            query: `
+                mutation ($input: UpdateUser!) {
+                    updateUserV2(input: $input) {
+                        id
+                    }
+                }
+            `,
+            variables: { input: updateUser },
+        };
+    }
+    static updateWorkflowEntity(updateWorkflowEntity) {
+        return {
+            query: `
+                mutation ($input: UpdateWorkflowEntity!) {
+                    updateWorkflowEntity(input: $input) {
+                        entity {
+                            id
+                            fields
+                        }
+                        refs {
+                            workflowEntityRefs {
+                                id
+                            }
+                            personRefs {
+                                id
+                            }
+                            workflowTemplateRefs {
+                                id
+                            }
+                        }
+                    }
+                }
+            `,
+            variables: { input: updateWorkflowEntity },
+        };
+    }
+    static updateWorkflowTemplate(updateWorkflowTemplate) {
+        return {
+            query: `
+                mutation ($input: UpdateWorkflowTemplate!) {
+                    updateWorkflowTemplate(input: $input) {
+                        id
+                    }
+                }
+            `,
+            variables: { input: updateWorkflowTemplate },
+        };
+    }
+}
+exports.CoastApiRequests = CoastApiRequests;

package/dist/models/coast-api/WorkflowEntityGqlFields.d.ts

@@ -0,0 +1,3 @@
+export declare const WorkflowEntityGqlFields: {
+    fields: string;
+};

package/dist/models/coast-api/WorkflowEntityGqlFields.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEntityGqlFields = void 0;
+const WorkflowTemplateGqlFields_1 = require("./WorkflowTemplateGqlFields");
+exports.WorkflowEntityGqlFields = {
+    fields: `
+        entity { id workflowTemplateId fields }
+        refs {
+            workflowEntityRefs { id workflowTemplateId fields }
+            personRefs { id }
+            workflowTemplateRefs { id components { ${WorkflowTemplateGqlFields_1.WorkflowTemplateGqlFields.componentFields} } }
+        }
+    `,
+};

package/dist/models/coast-api/WorkflowTemplateGqlFields.d.ts

@@ -0,0 +1,3 @@
+export declare const WorkflowTemplateGqlFields: {
+    componentFields: string;
+};

package/dist/models/coast-api/WorkflowTemplateGqlFields.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTemplateGqlFields = void 0;
+const inputComponentFields = [
+    'id',
+    'type',
+    'label',
+    'placeholder',
+    'readonly',
+    'required',
+    'isFilterable',
+    'isSortable',
+    'isServerManaged',
+];
+exports.WorkflowTemplateGqlFields = {
+    componentFields: `
+        ... on AddressComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        ... on AuditCheckboxComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        ... on AuditTagComponent {
+            ${inputComponentFields.join(' ')}
+            multiselect
+            options { label value archived }
+        }
+        ... on AuditTextComponent {
+            ${inputComponentFields.join(' ')}
+            maxlength
+            multiline
+        }
+        ... on CombinedTagsComponent {
+            id
+            type
+            label
+            icon
+            locked
+            isServerManaged
+            componentIds
+        }
+        ... on DateComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        ... on EmailComponent {
+            ${inputComponentFields.join(' ')}
+            default { value }
+        }
+        ... on FileComponent {
+            ${inputComponentFields.join(' ')}
+            acceptedContentTypes
+        }
+        ... on GeolocationComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        ... on InputButtonComponent {
+            id
+            type
+            locked
+            isServerManaged
+            buttonText
+            inputComponentId
+          }
+        ... on NumberComponent {
+            ${inputComponentFields.join(' ')}
+            format
+        }
+        ... on PersonComponent {
+            ${inputComponentFields.join(' ')}
+            default { token userIds }
+        }
+        ... on RelatedCardComponent {
+            ${inputComponentFields.join(' ')}
+            workflowTemplateId
+            default { cardIds }
+            listDefault {
+                sortByComponents { componentId direction }
+                filterByComponents {
+                    componentId
+                    value {
+                        containsCurrentUser { value }
+                        containsNumber { values }
+                        containsString { values }
+                        dateRange { before after }
+                        dateTokenIs { value }
+                        isEmpty { value }
+                        numberIs { value }
+                        stringWildcard { value }
+                    }
+                }
+                omniSearchQuery
+                limit
+                offset
+            }
+        }
+        ... on RelatedCardLookupComponent {
+            ${inputComponentFields.join(' ')}
+            relatedCardComponentId
+            lookupWorkflowTemplateId
+            lookupComponentId
+        }
+        ... on SignatureComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        ... on StaticTextComponent {
+            id type text
+        }
+        ... on SubformComponent {
+            ${inputComponentFields.join(' ')}
+            workflowTemplateIds
+            default { workflowTemplateId }
+        }
+        ... on TagComponent {
+            ${inputComponentFields.join(' ')}
+            multiselect
+            options { label value archived }
+            default { value }
+        }
+        ... on TextComponent {
+            ${inputComponentFields.join(' ')}
+            maxlength
+            multiline
+            default { text }
+        }
+        ... on TodoComponent {
+            ${inputComponentFields.join(' ')}
+        }
+        `,
+};

package/dist/modules/coast-api/CoastApiClient.d.ts

@@ -0,0 +1,46 @@
+import { SamlUser } from '@coast/core-api-types/auth/SamlUser';
+import { AutomationId } from '@coast/core-api-types/automations/AutomationId';
+import { BusinessId } from '@coast/core-api-types/business/BusinessId';
+import { Card } from '@coast/core-api-types/card/Card';
+import { UpdateCard } from '@coast/core-api-types/card/UpdateCard';
+import { Channel } from '@coast/core-api-types/channel/Channel';
+import { ListEntitiesFormData } from '@coast/core-api-types/export/ListEntitiesFormData';
+import { ListEntitiesFormDataResult } from '@coast/core-api-types/export/ListEntitiesFormDataResult';
+import { FileDetails } from '@coast/core-api-types/file-upload/FileDetails';
+import { CreateUserV2 } from '@coast/core-api-types/user/CreateUserV2';
+import { UpdateUser } from '@coast/core-api-types/user/UpdateUser';
+import { User } from '@coast/core-api-types/user/User';
+import { CreateWorkflowAutomationEvent } from '@coast/core-api-types/workflow-automation/CreateWorkflowAutomationEvent';
+import { AggregateNumberStats } from '@coast/core-api-types/workflow-template/entities/AggregateNumberStats';
+import { AggregateRelatedCardQuantity } from '@coast/core-api-types/workflow-template/entities/AggregateRelatedCardQuantity';
+import { CreateEntityAuditTrailEvent } from '@coast/core-api-types/workflow-template/entities/audit-trail/CreateEntityAuditTrailEvent';
+import { EntityAuditTrailEvent } from '@coast/core-api-types/workflow-template/entities/audit-trail/EntityAuditTrailEvent';
+import { CreateWorkflowEntity } from '@coast/core-api-types/workflow-template/entities/CreateWorkflowEntity';
+import { GetWorkflowEntityResult } from '@coast/core-api-types/workflow-template/entities/GetWorkflowEntityResult';
+import { UpdateWorkflowEntity } from '@coast/core-api-types/workflow-template/entities/UpdateWorkflowEntity';
+import { UpdateWorkflowTemplate } from '@coast/core-api-types/workflow-template/UpdateWorkflowTemplate';
+import { WorkflowTemplate } from '@coast/core-api-types/workflow-template/WorkflowTemplate';
+import { CoastLogger } from '../logger/CoastLogger';
+export declare class CoastApiClient {
+    private readonly coastApiEndpoint;
+    private readonly coastApiAuthToken;
+    private readonly logger;
+    constructor(coastApiEndpoint: string, coastApiAuthToken: string, logger: CoastLogger);
+    aggregateRelatedCardQuantityStats(businessId: BusinessId, aggregate: AggregateRelatedCardQuantity): Promise<AggregateNumberStats>;
+    createEntityAuditTrailEvent(businessId: BusinessId, createEntityAuditTrailEvent: CreateEntityAuditTrailEvent): Promise<EntityAuditTrailEvent>;
+    createUsers(createUsers: CreateUserV2[], businessId: BusinessId): Promise<User[] | undefined>;
+    createWorkflowAutomationEvent(businessId: BusinessId, createWorkflowAutomationEvent: CreateWorkflowAutomationEvent): Promise<boolean>;
+    createWorkflowEntity(businessId: BusinessId, sourceAutomationId: AutomationId, createWorkflowEntity: CreateWorkflowEntity): Promise<GetWorkflowEntityResult>;
+    getCard(businessId: BusinessId, cardId: string): Promise<Card | null>;
+    getChannel(businessId: BusinessId, channelId: number): Promise<Channel>;
+    getFileDetails(): Promise<FileDetails>;
+    getSamlUser(businessId: BusinessId, email: string, samlOrganizationId: string): Promise<SamlUser>;
+    getWorkflowEntity(businessId: BusinessId, id: string): Promise<GetWorkflowEntityResult>;
+    getWorkflowTemplate(businessId: BusinessId, workflowTemplateId: string): Promise<WorkflowTemplate>;
+    listWorkflowEntitiesFormData(businessId: BusinessId, filter: ListEntitiesFormData): Promise<ListEntitiesFormDataResult>;
+    updateCard(businessId: BusinessId, updateCard: UpdateCard): Promise<Card>;
+    updateUser(businessId: BusinessId, updateUser: UpdateUser): Promise<User>;
+    updateWorkflowEntity(businessId: BusinessId, sourceAutomationId: AutomationId, updateWorkflowEntity: UpdateWorkflowEntity): Promise<GetWorkflowEntityResult>;
+    updateWorkflowTemplate(businessId: BusinessId, updateWorkflowTemplate: UpdateWorkflowTemplate): Promise<WorkflowTemplate>;
+    private execute;
+}

package/dist/modules/coast-api/CoastApiClient.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoastApiClient = void 0;
+const HeaderKeys_1 = require("@coast/core-api-types/application/HeaderKeys");
+const common_1 = require("@nestjs/common");
+const lodash_1 = __importDefault(require("lodash"));
+const superagent_1 = __importDefault(require("superagent"));
+const CoastApiRequests_1 = require("../../models/coast-api/CoastApiRequests");
+const CoastApiClientGqlError_1 = require("./CoastApiClientGqlError");
+class CoastApiClient {
+    constructor(coastApiEndpoint, coastApiAuthToken, logger) {
+        this.coastApiEndpoint = coastApiEndpoint;
+        this.coastApiAuthToken = coastApiAuthToken;
+        this.logger = logger;
+    }
+    async aggregateRelatedCardQuantityStats(businessId, aggregate) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.aggregateRelatedCardQuantityStats(aggregate));
+        return response.body.data.aggregateRelatedCardQuantityStats;
+    }
+    async createEntityAuditTrailEvent(businessId, createEntityAuditTrailEvent) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.createEntityAuditTrailEvent(createEntityAuditTrailEvent));
+        return response.body.data.createEntityAuditTrailEvent;
+    }
+    async createUsers(createUsers, businessId) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.createUsers(createUsers));
+        return response.body.data.createUserV2;
+    }
+    async createWorkflowAutomationEvent(businessId, createWorkflowAutomationEvent) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.createWorkflowAutomationEvent(createWorkflowAutomationEvent), {
+            sourceAutomationId: createWorkflowAutomationEvent.context?.sourceAutomationId,
+        });
+        return response.body.data.createWorkflowAutomationEvent;
+    }
+    async createWorkflowEntity(businessId, sourceAutomationId, createWorkflowEntity) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.createWorkflowEntity(createWorkflowEntity), {
+            sourceAutomationId,
+        });
+        return response.body.data.createWorkflowEntity;
+    }
+    async getCard(businessId, cardId) {
+        try {
+            const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.getCard(cardId));
+            return response.body.data.getCard;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getChannel(businessId, channelId) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.getChannel(channelId));
+        return response.body.data.getChannel;
+    }
+    async getFileDetails() {
+        throw new common_1.NotImplementedException();
+    }
+    async getSamlUser(businessId, email, samlOrganizationId) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.getSamlUser(email, samlOrganizationId));
+        return response.body.data.getSamlUser;
+    }
+    async getWorkflowEntity(businessId, id) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.getWorkflowEntity(id));
+        return response.body.data.getWorkflowEntity;
+    }
+    async getWorkflowTemplate(businessId, workflowTemplateId) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.getWorkflowTemplate(workflowTemplateId));
+        return response.body.data.getWorkflowTemplate;
+    }
+    async listWorkflowEntitiesFormData(businessId, filter) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.listWorkflowEntitiesFormData(filter));
+        return response.body.data.listEntitiesFormData;
+    }
+    async updateCard(businessId, updateCard) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.updateCard(updateCard));
+        return response.body.data.updateCard;
+    }
+    async updateUser(businessId, updateUser) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.updateUser(updateUser));
+        return response.body.data.updateUserV2;
+    }
+    async updateWorkflowEntity(businessId, sourceAutomationId, updateWorkflowEntity) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.updateWorkflowEntity(updateWorkflowEntity), {
+            sourceAutomationId,
+        });
+        return response.body.data.updateWorkflowEntity;
+    }
+    async updateWorkflowTemplate(businessId, updateWorkflowTemplate) {
+        const response = await this.execute(businessId, CoastApiRequests_1.CoastApiRequests.updateWorkflowTemplate(updateWorkflowTemplate));
+        return response.body.data.updateWorkflowTemplate;
+    }
+    async execute(businessId, query, options = {}) {
+        const request = superagent_1.default.post(this.coastApiEndpoint).set(HeaderKeys_1.HeaderKeys.AUTHORIZATION, this.coastApiAuthToken);
+        request.set(HeaderKeys_1.HeaderKeys.BUSINESS_ID, businessId.toString());
+        if (!lodash_1.default.isNil(options?.sourceAutomationId)) {
+            request.set(HeaderKeys_1.HeaderKeys.SOURCE_AUTOMATION_ID, options.sourceAutomationId);
+        }
+        const response = await request.send(query).retry();
+        if (!lodash_1.default.isNil(response.body.errors)) {
+            this.logger.error({ errors: response.body.errors, firstError: response.body.errors[0] });
+            throw new CoastApiClientGqlError_1.CoastClientGqlError('Error in CoastClient', response.body.errors);
+        }
+        return response;
+    }
+}
+exports.CoastApiClient = CoastApiClient;

package/dist/modules/coast-api/CoastApiClientGqlError.d.ts

@@ -0,0 +1,12 @@
+interface GqlError {
+    extensions: {
+        code: number;
+    };
+    message: string;
+    path: string[];
+}
+export declare class CoastClientGqlError extends Error {
+    readonly details: GqlError[];
+    constructor(message: string, details: GqlError[]);
+}
+export {};

package/dist/modules/coast-api/CoastApiClientGqlError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoastClientGqlError = void 0;
+class CoastClientGqlError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+    }
+}
+exports.CoastClientGqlError = CoastClientGqlError;

package/dist/modules/coast-api/CoastApiModule.d.ts

@@ -0,0 +1,2 @@
+export declare class CoastApiModule {
+}

package/dist/modules/coast-api/CoastApiModule.js

@@ -0,0 +1,28 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoastApiModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const CoastLogger_1 = require("../logger/CoastLogger");
+const CoastApiClient_1 = require("./CoastApiClient");
+const coastApiClientFactory_1 = require("./coastApiClientFactory");
+const coastApiProvider = {
+    inject: [config_1.ConfigService, CoastLogger_1.CoastLogger],
+    provide: CoastApiClient_1.CoastApiClient,
+    useFactory: coastApiClientFactory_1.coastApiClientFactory,
+};
+let CoastApiModule = class CoastApiModule {
+};
+exports.CoastApiModule = CoastApiModule;
+exports.CoastApiModule = CoastApiModule = __decorate([
+    (0, common_1.Module)({
+        exports: [CoastApiClient_1.CoastApiClient],
+        providers: [coastApiProvider],
+    })
+], CoastApiModule);

package/dist/modules/coast-api/coastApiClientFactory.d.ts

@@ -0,0 +1,4 @@
+import { ConfigService } from '@nestjs/config';
+import { CoastLogger } from '../logger/CoastLogger';
+import { CoastApiClient } from './CoastApiClient';
+export declare const coastApiClientFactory: (configService: ConfigService, logger: CoastLogger) => CoastApiClient;

package/dist/modules/coast-api/coastApiClientFactory.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coastApiClientFactory = void 0;
+const CoastApiClient_1 = require("./CoastApiClient");
+const coastApiClientFactory = (configService, logger) => {
+    return new CoastApiClient_1.CoastApiClient(configService.getOrThrow('COAST_API_ENDPOINT'), configService.getOrThrow('COAST_API_AUTH_TOKEN'), logger);
+};
+exports.coastApiClientFactory = coastApiClientFactory;

package/dist/modules/logger/CoastLogger.d.ts

@@ -1,8 +1,8 @@
 import { LoggerService } from '@nestjs/common';
 export declare abstract class CoastLogger implements LoggerService {
+    abstract debug(message: unknown): void;
     abstract error(message: unknown, trace?: string): void;
     abstract log(message: unknown): void;
-    abstract warn(message: unknown): void;
-    abstract debug(message: unknown): void;
     abstract verbose(message: unknown): void;
+    abstract warn(message: unknown): void;
 }

package/dist/modules/logger/LoggerModule.d.ts

@@ -1,5 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
 export declare class LoggerModule {
-    static forRootAsync(): DynamicModule;
     static disabled(): DynamicModule;
+    static forRootAsync(): DynamicModule;
 }

package/dist/modules/logger/LoggerModule.js

@@ -10,38 +10,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerModule = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
+const TraceManager_1 = require("../trace/TraceManager");
+const TraceModule_1 = require("../trace/TraceModule");
+const CoastLogger_1 = require("./CoastLogger");
 const PinoLogger_1 = require("./PinoLogger");
 const SilentLogger_1 = require("./SilentLogger");
-const CoastLogger_1 = require("./CoastLogger");
 let LoggerModule = LoggerModule_1 = class LoggerModule {
-    static forRootAsync() {
+    static disabled() {
         const coastLogger = {
-            inject: [config_1.ConfigService],
             provide: CoastLogger_1.CoastLogger,
-            useFactory: (configService) => new PinoLogger_1.PinoLogger(configService),
+            useValue: new SilentLogger_1.SilentLogger(),
         };
         return {
-            module: LoggerModule_1,
+            exports: [coastLogger],
             imports: [config_1.ConfigModule],
+            module: LoggerModule_1,
             providers: [coastLogger],
-            exports: [coastLogger],
         };
     }
-    static disabled() {
+    static forRootAsync() {
         const coastLogger = {
+            inject: [config_1.ConfigService, TraceManager_1.TraceManager],
             provide: CoastLogger_1.CoastLogger,
-            useValue: new SilentLogger_1.SilentLogger(),
+            useFactory: (configService, traceManager) => new PinoLogger_1.PinoLogger(configService, traceManager),
         };
         return {
+            exports: [coastLogger],
+            imports: [config_1.ConfigModule, TraceModule_1.TraceModule],
             module: LoggerModule_1,
-            imports: [config_1.ConfigModule],
             providers: [coastLogger],
-            exports: [coastLogger],
         };
     }
 };
 exports.LoggerModule = LoggerModule;
 exports.LoggerModule = LoggerModule = LoggerModule_1 = __decorate([
-    (0, common_1.Module)({}),
-    (0, common_1.Global)()
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
 ], LoggerModule);

package/dist/modules/logger/PinoLogger.d.ts

@@ -1,11 +1,13 @@
 import { ConfigService } from '@nestjs/config';
+import { TraceManager } from '../trace/TraceManager';
 import { CoastLogger } from './CoastLogger';
 export declare class PinoLogger extends CoastLogger {
     private readonly instance;
-    constructor(configService: ConfigService);
+    private readonly traceManager?;
+    constructor(configService: ConfigService, traceManager: TraceManager);
+    debug(message: unknown): void;
     error(message: unknown, trace?: string): void;
     log(message: unknown): void;
-    warn(message: unknown): void;
-    debug(message: unknown): void;
     verbose(message: unknown): void;
+    warn(message: unknown): void;
 }

package/dist/modules/logger/PinoLogger.js

@@ -16,9 +16,10 @@ exports.PinoLogger = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const pino_1 = __importDefault(require("pino"));
+const TraceManager_1 = require("../trace/TraceManager");
 const CoastLogger_1 = require("./CoastLogger");
 let PinoLogger = class PinoLogger extends CoastLogger_1.CoastLogger {
-    constructor(configService) {
+    constructor(configService, traceManager) {
         super();
         const level = configService.get('LOG_LEVEL');
         const redact = [
@@ -34,20 +35,26 @@ let PinoLogger = class PinoLogger extends CoastLogger_1.CoastLogger {
         const pino = configService.get('LOG_PRETTY')
             ? (0, pino_1.default)({
                 level,
+                mixin: () => this.traceManager?.getTrace() ?? {},
                 redact,
                 transport: {
-                    target: 'pino-pretty',
                     options: {
                         colorize: true,
                         translateTime: true,
                     },
+                    target: 'pino-pretty',
                 },
             })
             : (0, pino_1.default)({
                 level,
+                mixin: () => this.traceManager?.getTrace() ?? {},
                 redact,
             });
         this.instance = pino;
+        this.traceManager = traceManager;
+    }
+    debug(message) {
+        this.instance.debug(message);
     }
     error(message, trace = '') {
         this.instance.error(message, trace);
@@ -55,18 +62,15 @@ let PinoLogger = class PinoLogger extends CoastLogger_1.CoastLogger {
     log(message) {
         this.instance.info(message);
     }
-    warn(message) {
-        this.instance.warn(message);
-    }
-    debug(message) {
-        this.instance.debug(message);
-    }
     verbose(message) {
         this.instance.trace(message);
     }
+    warn(message) {
+        this.instance.warn(message);
+    }
 };
 exports.PinoLogger = PinoLogger;
 exports.PinoLogger = PinoLogger = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [config_1.ConfigService])
+    __metadata("design:paramtypes", [config_1.ConfigService, TraceManager_1.TraceManager])
 ], PinoLogger);

package/dist/modules/logger/SilentLogger.d.ts

@@ -1,8 +1,8 @@
 import { CoastLogger } from './CoastLogger';
 export declare class SilentLogger extends CoastLogger {
-    log(): void;
-    error(): void;
-    warn(): void;
     debug(): void;
+    error(): void;
+    log(): void;
     verbose(): void;
+    warn(): void;
 }

package/dist/modules/logger/SilentLogger.js

@@ -3,19 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SilentLogger = void 0;
 const CoastLogger_1 = require("./CoastLogger");
 class SilentLogger extends CoastLogger_1.CoastLogger {
-    log() {
+    debug() {
         return;
     }
     error() {
         return;
     }
-    warn() {
+    log() {
         return;
     }
-    debug() {
+    verbose() {
         return;
     }
-    verbose() {
+    warn() {
         return;
     }
 }

package/dist/modules/trace/Trace.d.ts

@@ -1,5 +1,5 @@
 import { TraceId } from './TraceId';
 export interface Trace {
-    traceId: TraceId;
     subtraceId?: TraceId;
+    traceId: TraceId;
 }

package/dist/modules/trace/TraceManager.js

@@ -13,8 +13,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceManager = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
 const common_1 = require("@nestjs/common");
+const node_async_hooks_1 = require("node:async_hooks");
 const uuid_1 = require("uuid");
 const TraceId_1 = require("./TraceId");
 let TraceManager = class TraceManager {
@@ -26,8 +26,8 @@ let TraceManager = class TraceManager {
     }
     withNewTrace(fn, traceId) {
         const trace = {
-            traceId: traceId ?? (0, TraceId_1.TraceId)((0, uuid_1.v4)()),
             subtraceId: (0, TraceId_1.TraceId)((0, uuid_1.v4)()),
+            traceId: traceId ?? (0, TraceId_1.TraceId)((0, uuid_1.v4)()),
         };
         return this.asyncLocalStorage.run(trace, fn);
     }

package/dist/modules/trace/TraceModule.js

@@ -8,15 +8,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceModule = void 0;
 const common_1 = require("@nestjs/common");
-const TraceManager_1 = require("./TraceManager");
-const TraceInterceptor_1 = require("./TraceInterceptor");
 const node_async_hooks_1 = require("node:async_hooks");
+const TraceInterceptor_1 = require("./TraceInterceptor");
+const TraceManager_1 = require("./TraceManager");
 let TraceModule = class TraceModule {
 };
 exports.TraceModule = TraceModule;
 exports.TraceModule = TraceModule = __decorate([
     (0, common_1.Module)({
-        providers: [(node_async_hooks_1.AsyncLocalStorage), TraceManager_1.TraceManager, TraceInterceptor_1.TraceInterceptor],
         exports: [TraceManager_1.TraceManager, TraceInterceptor_1.TraceInterceptor],
+        providers: [(node_async_hooks_1.AsyncLocalStorage), TraceManager_1.TraceManager, TraceInterceptor_1.TraceInterceptor],
     })
 ], TraceModule);

package/dist/modules/utils/graphql/GqlRequestBody.d.ts

@@ -0,0 +1,8 @@
+export interface GqlRequestBody<T, Response = any> {
+    query: string;
+    variables?: {
+        id: T;
+    } | {
+        input: T;
+    };
+}

package/dist/modules/utils/graphql/GqlRequestBody.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/utils/graphql/GqlResponse.d.ts

@@ -0,0 +1,14 @@
+import { Response } from 'superagent';
+export type GqlResponse<T> = Omit<Response, 'body'> & {
+    body: TypedBody<T>;
+};
+interface TypedBody<T> {
+    data: T;
+    errors?: {
+        extensions?: {
+            code: number;
+        };
+        message: string;
+    }[];
+}
+export {};

package/dist/modules/utils/graphql/GqlResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/utils/streams/Generators.d.ts

@@ -1,5 +1,5 @@
 export declare class Generators {
     static chunked<T>(iterator: AsyncGenerator<T>, size: number): AsyncGenerator<T[]>;
-    static take<T>(iterator: AsyncGenerator<T>, size: number): AsyncGenerator<T>;
     static map<T, Y>(iterator: AsyncGenerator<T>, mapper: (data: T) => Y): AsyncGenerator<Y>;
+    static take<T>(iterator: AsyncGenerator<T>, size: number): AsyncGenerator<T>;
 }

package/dist/modules/utils/streams/Generators.js

@@ -13,6 +13,11 @@ class Generators {
         }
         yield chunk;
     }
+    static async *map(iterator, mapper) {
+        for await (const item of iterator) {
+            yield mapper(item);
+        }
+    }
     static async *take(iterator, size) {
         let count = 0;
         for await (const item of iterator) {
@@ -25,10 +30,5 @@ class Generators {
             }
         }
     }
-    static async *map(iterator, mapper) {
-        for await (const item of iterator) {
-            yield mapper(item);
-        }
-    }
 }
 exports.Generators = Generators;

package/dist/modules/utils/streams/test/GeneratorsTest.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Generators_1 = require("../Generators");
 const common_test_1 = require("@paradoxical-io/common-test");
+const Generators_1 = require("../Generators");
 test('take async', async () => {
     const data = [];
     for await (const i of Generators_1.Generators.take(infinityAsync(), 10)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coast/service-common",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Common service package",
   "main": "./modules",
   "types": "./modules",
@@ -25,14 +25,18 @@
   "scripts": {
     "prebuild": "rimraf dist",
     "build": "yarn prebuild && yarn dlx @nestjs/cli build",
-    "lint": "eslint --fix"
+    "lint": "eslint",
+    "lint:fix": "eslint --fix"
   },
   "dependencies": {
     "@paradoxical-io/types": "^1.0.7",
+    "lodash": "^4.17.21",
     "pino": "^9.6.0",
+    "superagent": "^10.1.1",
     "uuid": "^11.0.5"
   },
   "devDependencies": {
+    "@coast/core-api-types": "^1.2.24",
     "@faker-js/faker": "^9.4.0",
     "@nestjs/cli": "^10.4.4",
     "@nestjs/common": "^10.4.1",
@@ -40,13 +44,16 @@
     "@nestjs/schematics": "^10.1.4",
     "@paradoxical-io/common-test": "^1.0.7",
     "@types/jest": "^29.5.12",
+    "@types/lodash": "^4",
     "@types/node": "^22.5.0",
+    "@types/superagent": "^8.1.9",
     "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^8.3.0",
     "@typescript-eslint/parser": "^8.3.0",
     "dotenv": "^16.4.7",
     "eslint": "^9.9.1",
     "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-perfectionist": "^4.8.0",
     "eslint-plugin-prettier": "^5.2.1",
     "husky": "^9.1.7",
     "jest": "^29.7.0",