@accounter/server 0.0.8-alpha-20251021150615-800574fc6d416cd319de216c97b431643d8958a2 → 0.0.8-alpha-20251021225827-178e480c997a9811913e16f85cb94329041b096e

package/src/modules/contracts/__generated__/contracts.types.ts

@@ -3,6 +3,8 @@ export type currency = 'AUD' | 'CAD' | 'ETH' | 'EUR' | 'GBP' | 'GRT' | 'ILS' | '
 
 export type document_type = 'CREDIT_INVOICE' | 'INVOICE' | 'INVOICE_RECEIPT' | 'OTHER' | 'PROFORMA' | 'RECEIPT' | 'UNPROCESSED';
 
+export type DateOrString = Date | string;
+
 /** 'GetAllOpenContracts' parameters type */
 export type IGetAllOpenContractsParams = void;
 
@@ -31,3 +33,162 @@ export interface IGetAllOpenContractsQuery {
   result: IGetAllOpenContractsResult;
 }
 
+/** 'GetContractsByIds' parameters type */
+export interface IGetContractsByIdsParams {
+  ids: readonly (string | null | void)[];
+}
+
+/** 'GetContractsByIds' return type */
+export interface IGetContractsByIdsResult {
+  amount: number;
+  billing_cycle: string;
+  client_id: string;
+  currency: currency;
+  document_type: document_type;
+  end_date: Date;
+  id: string;
+  is_active: boolean | null;
+  ms_cloud: string | null;
+  plan: string | null;
+  product: string | null;
+  purchase_order: string | null;
+  remarks: string | null;
+  signed_agreement: string | null;
+  start_date: Date;
+}
+
+/** 'GetContractsByIds' query type */
+export interface IGetContractsByIdsQuery {
+  params: IGetContractsByIdsParams;
+  result: IGetContractsByIdsResult;
+}
+
+/** 'GetContractsByClientIds' parameters type */
+export interface IGetContractsByClientIdsParams {
+  clientIds: readonly (string | null | void)[];
+}
+
+/** 'GetContractsByClientIds' return type */
+export interface IGetContractsByClientIdsResult {
+  amount: number;
+  billing_cycle: string;
+  client_id: string;
+  currency: currency;
+  document_type: document_type;
+  end_date: Date;
+  id: string;
+  is_active: boolean | null;
+  ms_cloud: string | null;
+  plan: string | null;
+  product: string | null;
+  purchase_order: string | null;
+  remarks: string | null;
+  signed_agreement: string | null;
+  start_date: Date;
+}
+
+/** 'GetContractsByClientIds' query type */
+export interface IGetContractsByClientIdsQuery {
+  params: IGetContractsByClientIdsParams;
+  result: IGetContractsByClientIdsResult;
+}
+
+/** 'DeleteContract' parameters type */
+export interface IDeleteContractParams {
+  id?: string | null | void;
+}
+
+/** 'DeleteContract' return type */
+export type IDeleteContractResult = void;
+
+/** 'DeleteContract' query type */
+export interface IDeleteContractQuery {
+  params: IDeleteContractParams;
+  result: IDeleteContractResult;
+}
+
+/** 'UpdateContract' parameters type */
+export interface IUpdateContractParams {
+  amount?: number | null | void;
+  billing_cycle?: string | null | void;
+  client_id?: string | null | void;
+  contractId?: string | null | void;
+  currency?: currency | null | void;
+  document_type?: document_type | null | void;
+  end_date?: DateOrString | null | void;
+  is_active?: boolean | null | void;
+  ms_cloud?: string | null | void;
+  plan?: string | null | void;
+  product?: string | null | void;
+  purchase_order?: string | null | void;
+  remarks?: string | null | void;
+  start_date?: DateOrString | null | void;
+}
+
+/** 'UpdateContract' return type */
+export interface IUpdateContractResult {
+  amount: number;
+  billing_cycle: string;
+  client_id: string;
+  currency: currency;
+  document_type: document_type;
+  end_date: Date;
+  id: string;
+  is_active: boolean | null;
+  ms_cloud: string | null;
+  plan: string | null;
+  product: string | null;
+  purchase_order: string | null;
+  remarks: string | null;
+  signed_agreement: string | null;
+  start_date: Date;
+}
+
+/** 'UpdateContract' query type */
+export interface IUpdateContractQuery {
+  params: IUpdateContractParams;
+  result: IUpdateContractResult;
+}
+
+/** 'InsertContract' parameters type */
+export interface IInsertContractParams {
+  amount?: number | null | void;
+  billingCycle?: string | null | void;
+  clientId?: string | null | void;
+  currency?: currency | null | void;
+  documentType?: document_type | null | void;
+  endDate?: DateOrString | null | void;
+  isActive?: boolean | null | void;
+  msCloud?: string | null | void;
+  plan?: string | null | void;
+  product?: string | null | void;
+  purchaseOrder?: string | null | void;
+  remarks?: string | null | void;
+  startDate?: DateOrString | null | void;
+}
+
+/** 'InsertContract' return type */
+export interface IInsertContractResult {
+  amount: number;
+  billing_cycle: string;
+  client_id: string;
+  currency: currency;
+  document_type: document_type;
+  end_date: Date;
+  id: string;
+  is_active: boolean | null;
+  ms_cloud: string | null;
+  plan: string | null;
+  product: string | null;
+  purchase_order: string | null;
+  remarks: string | null;
+  signed_agreement: string | null;
+  start_date: Date;
+}
+
+/** 'InsertContract' query type */
+export interface IInsertContractQuery {
+  params: IInsertContractParams;
+  result: IInsertContractResult;
+}
+

package/src/modules/contracts/__generated__/types.ts

@@ -2,8 +2,9 @@ import * as Types from "../../../__generated__/types.js";
 import * as gm from "graphql-modules";
 export namespace ContractsModule {
   interface DefinedFields {
-    Query: 'allOpenContracts';
-    Contract: 'id' | 'client' | 'purchaseOrder' | 'startDate' | 'endDate' | 'remarks' | 'amount' | 'documentType' | 'billingCycle' | 'isActive' | 'product' | 'plan' | 'signedAgreement' | 'msCloud';
+    Query: 'allOpenContracts' | 'contractsByClient';
+    Mutation: 'updateContract' | 'deleteContract' | 'createContract';
+    Contract: 'id' | 'client' | 'purchaseOrder' | 'startDate' | 'endDate' | 'remarks' | 'amount' | 'documentType' | 'billingCycle' | 'isActive' | 'product' | 'plan' | 'msCloud';
   };
   
   interface DefinedEnumValues {
@@ -12,9 +13,17 @@ export namespace ContractsModule {
     SubscriptionPlan: 'ENTERPRISE' | 'PRO';
   };
   
+  interface DefinedInputFields {
+    CreateContractInput: 'clientId' | 'purchaseOrder' | 'startDate' | 'endDate' | 'remarks' | 'amount' | 'documentType' | 'billingCycle' | 'product' | 'plan' | 'msCloud' | 'isActive';
+    UpdateContractInput: 'clientId' | 'purchaseOrder' | 'startDate' | 'endDate' | 'remarks' | 'amount' | 'documentType' | 'billingCycle' | 'product' | 'plan' | 'msCloud' | 'isActive';
+  };
+  
   export type Query = Pick<Types.Query, DefinedFields['Query']>;
   export type Contract = Pick<Types.Contract, DefinedFields['Contract']>;
   export type UUID = Types.Uuid;
+  export type Mutation = Pick<Types.Mutation, DefinedFields['Mutation']>;
+  export type UpdateContractInput = Pick<Types.UpdateContractInput, DefinedInputFields['UpdateContractInput']>;
+  export type CreateContractInput = Pick<Types.CreateContractInput, DefinedInputFields['CreateContractInput']>;
   export type Client = Types.Client;
   export type TimelessDate = Types.TimelessDate;
   export type FinancialAmount = Types.FinancialAmount;
@@ -23,12 +32,15 @@ export namespace ContractsModule {
   export type Product = DefinedEnumValues['Product'];
   export type SubscriptionPlan = DefinedEnumValues['SubscriptionPlan'];
   export type URL = Types.Url;
+  export type FinancialAmountInput = Types.FinancialAmountInput;
   
   export type QueryResolvers = Pick<Types.QueryResolvers, DefinedFields['Query']>;
+  export type MutationResolvers = Pick<Types.MutationResolvers, DefinedFields['Mutation']>;
   export type ContractResolvers = Pick<Types.ContractResolvers, DefinedFields['Contract'] | '__isTypeOf'>;
   
   export interface Resolvers {
     Query?: QueryResolvers;
+    Mutation?: MutationResolvers;
     Contract?: ContractResolvers;
   };
   
@@ -39,6 +51,13 @@ export namespace ContractsModule {
     Query?: {
       '*'?: gm.Middleware[];
       allOpenContracts?: gm.Middleware[];
+      contractsByClient?: gm.Middleware[];
+    };
+    Mutation?: {
+      '*'?: gm.Middleware[];
+      updateContract?: gm.Middleware[];
+      deleteContract?: gm.Middleware[];
+      createContract?: gm.Middleware[];
     };
     Contract?: {
       '*'?: gm.Middleware[];
@@ -54,7 +73,6 @@ export namespace ContractsModule {
       isActive?: gm.Middleware[];
       product?: gm.Middleware[];
       plan?: gm.Middleware[];
-      signedAgreement?: gm.Middleware[];
       msCloud?: gm.Middleware[];
     };
   };

package/src/modules/contracts/providers/contracts.provider.ts

@@ -1,14 +1,130 @@
+import DataLoader from 'dataloader';
 import { Injectable, Scope } from 'graphql-modules';
 import { DBProvider } from '@modules/app-providers/db.provider.js';
 import { sql } from '@pgtyped/runtime';
 import { getCacheInstance } from '@shared/helpers';
-import type { IGetAllOpenContractsQuery, IGetAllOpenContractsResult } from '../types.js';
+import type {
+  IDeleteContractQuery,
+  IGetAllOpenContractsQuery,
+  IGetAllOpenContractsResult,
+  IGetContractsByClientIdsQuery,
+  IGetContractsByIdsQuery,
+  IInsertContractParams,
+  IInsertContractQuery,
+  IUpdateContractParams,
+  IUpdateContractQuery,
+} from '../types.js';
 
 const getAllOpenContracts = sql<IGetAllOpenContractsQuery>`
     SELECT *
     FROM accounter_schema.clients_contracts
     WHERE is_active IS TRUE;`;
 
+const getContractsByIds = sql<IGetContractsByIdsQuery>`
+    SELECT *
+    FROM accounter_schema.clients_contracts
+    WHERE id In $$ids;`;
+
+const getContractsByClientIds = sql<IGetContractsByClientIdsQuery>`
+    SELECT *
+    FROM accounter_schema.clients_contracts
+    WHERE client_id IN $$clientIds;`;
+
+const deleteContract = sql<IDeleteContractQuery>`
+    DELETE FROM accounter_schema.clients_contracts
+    WHERE id = $id;`;
+
+const updateContract = sql<IUpdateContractQuery>`
+      UPDATE accounter_schema.clients_contracts
+      SET
+      client_id = COALESCE(
+        $client_id,
+        client_id
+      ),
+      purchase_order = COALESCE(
+        $purchase_order,
+        purchase_order
+      ),
+      start_date = COALESCE(
+        $start_date,
+        start_date
+      ),
+      end_date = COALESCE(
+        $end_date,
+        end_date
+      ),
+      remarks = COALESCE(
+        $remarks,
+        remarks
+      ),
+      document_type = COALESCE(
+        $document_type,
+        document_type
+      ),
+      amount = COALESCE(
+        $amount,
+        amount
+      ),
+      currency = COALESCE(
+        $currency,
+        currency
+      ),
+      billing_cycle = COALESCE(
+        $billing_cycle,
+        billing_cycle
+      ),
+      product = COALESCE(
+        $product,
+        product
+      ),
+      plan = COALESCE(
+        $plan,
+        plan
+      ),
+      is_active = COALESCE(
+        $is_active,
+        is_active
+      ),
+      ms_cloud = COALESCE(
+        $ms_cloud,
+        ms_cloud
+      )
+      WHERE
+        id = $contractId
+      RETURNING *;
+    `;
+
+const insertContract = sql<IInsertContractQuery>`
+        INSERT INTO accounter_schema.clients_contracts (
+          client_id,
+          purchase_order,
+          start_date,
+          end_date,
+          remarks,
+          document_type,
+          amount,
+          currency,
+          billing_cycle,
+          product,
+          plan,
+          is_active,
+          ms_cloud
+        )
+        VALUES ($clientId,
+          $purchaseOrder,
+          $startDate,
+          $endDate,
+          $remarks,
+          $documentType,
+          $amount,
+          $currency,
+          $billingCycle,
+          $product,
+          $plan,
+          $isActive,
+          $msCloud)
+        RETURNING *;`;
+
 @Injectable({
   scope: Scope.Singleton,
   global: true,
@@ -36,6 +152,60 @@ export class ContractsProvider {
     });
   }
 
+  private async contractsByIds(ids: readonly string[]) {
+    const contracts = await getContractsByIds.run({ ids }, this.dbProvider);
+    return ids.map(id => contracts.find(contract => contract.id === id));
+  }
+
+  public getContractsByIdLoader = new DataLoader(
+    (ids: readonly string[]) => this.contractsByIds(ids),
+    {
+      cacheKeyFn: id => `contract-${id}`,
+      cacheMap: this.cache,
+    },
+  );
+
+  private async contractsByClients(clientIds: readonly string[]) {
+    const contracts = await getContractsByClientIds.run({ clientIds }, this.dbProvider);
+    return clientIds.map(clientId => contracts.filter(contract => contract.client_id === clientId));
+  }
+
+  public getContractsByClientIdLoader = new DataLoader(
+    (ids: readonly string[]) => this.contractsByClients(ids),
+    {
+      cacheKeyFn: id => `client-contracts-${id}`,
+      cacheMap: this.cache,
+    },
+  );
+
+  public async createContract(params: IInsertContractParams) {
+    this.clearCache();
+    const [newContract] = await insertContract.run(params, this.dbProvider);
+    this.cache.set(`contract-${newContract.id}`, newContract);
+    return newContract;
+  }
+
+  public async updateContract(params: IUpdateContractParams) {
+    this.clearCache();
+    const [updatedContract] = await updateContract.run(params, this.dbProvider);
+    this.cache.set(`contract-${updatedContract.id}`, updatedContract);
+    return updatedContract;
+  }
+
+  public async deleteContract(contractId: string) {
+    await deleteContract.run({ id: contractId }, this.dbProvider);
+    this.clearCache();
+    return true;
+  }
+
+  public async invalidateCacheForContract(contractId: string) {
+    const contract = await this.getContractsByIdLoader.load(contractId);
+    if (contract) {
+      this.cache.delete(`client-contracts-${contract.client_id}`);
+    }
+    this.cache.delete(`contract-${contractId}`);
+  }
+
   public clearCache() {
     this.cache.clear();
   }

package/src/modules/contracts/resolvers/contracts.resolver.ts

@@ -8,7 +8,7 @@ import {
   normalizeSubscriptionPlan,
 } from '../helpers/contracts.helper.js';
 import { ContractsProvider } from '../providers/contracts.provider.js';
-import type { ContractsModule } from '../types.js';
+import type { ContractsModule, IInsertContractParams, IUpdateContractParams } from '../types.js';
 
 export const contractsResolvers: ContractsModule.Resolvers = {
   Query: {
@@ -20,6 +20,72 @@ export const contractsResolvers: ContractsModule.Resolvers = {
         throw new GraphQLError('Error fetching countries');
       }
     },
+    contractsByClient: async (_, { clientId }, { injector }) => {
+      try {
+        return injector.get(ContractsProvider).getContractsByClientIdLoader.load(clientId);
+      } catch (e) {
+        const message = 'Error fetching contracts by client';
+        console.error(message, e);
+        throw new GraphQLError(message);
+      }
+    },
+  },
+  Mutation: {
+    createContract: async (_, { input }, { injector }) => {
+      try {
+        const params: IInsertContractParams = {
+          amount: input.amount.raw,
+          billingCycle: input.billingCycle,
+          clientId: input.clientId,
+          currency: input.amount.currency,
+          documentType: input.documentType,
+          endDate: input.endDate,
+          isActive: input.isActive,
+          msCloud: input.msCloud?.toString(),
+          plan: input.plan,
+          product: input.product,
+          purchaseOrder: input.purchaseOrder,
+          remarks: input.remarks,
+          startDate: input.startDate,
+        };
+        return injector.get(ContractsProvider).createContract(params);
+      } catch (e) {
+        console.error('Error creating contract', e);
+        throw new GraphQLError('Error creating contract');
+      }
+    },
+    updateContract: async (_, { contractId, input }, { injector }) => {
+      try {
+        const params: IUpdateContractParams = {
+          contractId,
+          amount: input.amount?.raw,
+          billing_cycle: input.billingCycle,
+          client_id: input.clientId,
+          currency: input.amount?.currency,
+          document_type: input.documentType,
+          end_date: input.endDate,
+          is_active: input.isActive,
+          ms_cloud: input.msCloud?.toString(),
+          plan: input.plan,
+          product: input.product,
+          purchase_order: input.purchaseOrder,
+          remarks: input.remarks,
+          start_date: input.startDate,
+        };
+        return injector.get(ContractsProvider).updateContract(params);
+      } catch (e) {
+        console.error('Error updating contract', e);
+        throw new GraphQLError('Error updating contract');
+      }
+    },
+    deleteContract: async (_, { id }, { injector }) => {
+      try {
+        return injector.get(ContractsProvider).deleteContract(id);
+      } catch (e) {
+        console.error('Error deleting contract', e);
+        throw new GraphQLError('Error deleting contract');
+      }
+    },
   },
   Contract: {
     id: dbContract => dbContract.id,
@@ -46,7 +112,6 @@ export const contractsResolvers: ContractsModule.Resolvers = {
     isActive: dbContract => dbContract.is_active ?? false, //Boolean!
     product: dbContract => normalizeProduct(dbContract.product), //Product!
     plan: dbContract => normalizeSubscriptionPlan(dbContract.plan), //SubscriptionPlan!
-    signedAgreement: dbContract => dbContract.signed_agreement, //URL
     msCloud: dbContract => dbContract.ms_cloud, //URL
   },
 };

package/src/modules/contracts/typeDefs/contracts.graphql.ts

@@ -3,6 +3,14 @@ import { gql } from 'graphql-modules';
 export default gql`
   extend type Query {
     allOpenContracts: [Contract!]! @auth(role: ACCOUNTANT)
+    contractsByClient(clientId: UUID!): [Contract!]! @auth(role: ACCOUNTANT)
+  }
+
+  extend type Mutation {
+    updateContract(contractId: UUID!, input: UpdateContractInput!): Contract!
+      @auth(role: ACCOUNTANT)
+    deleteContract(id: UUID!): Boolean! @auth(role: ACCOUNTANT)
+    createContract(input: CreateContractInput!): Contract! @auth(role: ACCOUNTANT)
   }
 
   " a client contract "
@@ -19,7 +27,6 @@ export default gql`
     isActive: Boolean!
     product: Product
     plan: SubscriptionPlan
-    signedAgreement: URL
     msCloud: URL
   }
 
@@ -40,4 +47,36 @@ export default gql`
     ENTERPRISE
     PRO
   }
+
+  " input for creating a new contract "
+  input CreateContractInput {
+    clientId: UUID!
+    purchaseOrder: String
+    startDate: TimelessDate!
+    endDate: TimelessDate!
+    remarks: String
+    amount: FinancialAmountInput!
+    documentType: DocumentType!
+    billingCycle: BillingCycle!
+    product: Product
+    plan: SubscriptionPlan
+    msCloud: URL
+    isActive: Boolean!
+  }
+
+  " input for updating a contract "
+  input UpdateContractInput {
+    clientId: UUID
+    purchaseOrder: String
+    startDate: TimelessDate
+    endDate: TimelessDate
+    remarks: String
+    amount: FinancialAmountInput
+    documentType: DocumentType
+    billingCycle: BillingCycle
+    product: Product
+    plan: SubscriptionPlan
+    msCloud: URL
+    isActive: Boolean
+  }
 `;

package/src/modules/documents/__generated__/documents.types.ts

@@ -110,6 +110,41 @@ export interface IGetDocumentsByIdsQuery {
   result: IGetDocumentsByIdsResult;
 }
 
+/** 'GetDocumentsByBusinessIds' parameters type */
+export interface IGetDocumentsByBusinessIdsParams {
+  Ids: readonly (string | null | void)[];
+}
+
+/** 'GetDocumentsByBusinessIds' return type */
+export interface IGetDocumentsByBusinessIdsResult {
+  allocation_number: string | null;
+  charge_id: string | null;
+  created_at: Date;
+  creditor_id: string | null;
+  currency_code: currency | null;
+  date: Date | null;
+  debtor_id: string | null;
+  exchange_rate_override: string | null;
+  file_hash: string | null;
+  file_url: string | null;
+  id: string;
+  image_url: string | null;
+  is_reviewed: boolean;
+  modified_at: Date;
+  no_vat_amount: string | null;
+  serial_number: string | null;
+  total_amount: number | null;
+  type: document_type;
+  vat_amount: number | null;
+  vat_report_date_override: Date | null;
+}
+
+/** 'GetDocumentsByBusinessIds' query type */
+export interface IGetDocumentsByBusinessIdsQuery {
+  params: IGetDocumentsByBusinessIdsParams;
+  result: IGetDocumentsByBusinessIdsResult;
+}
+
 /** 'GetDocumentsByHashes' parameters type */
 export interface IGetDocumentsByHashesParams {
   hashes: readonly (string | null | void)[];

package/src/modules/documents/__generated__/types.ts

@@ -3,7 +3,7 @@ import * as gm from "graphql-modules";
 export namespace DocumentsModule {
   interface DefinedFields {
     DocumentSuggestions: 'owner' | 'counterparty' | 'amount' | 'isIncome';
-    Query: 'documents' | 'documentsByFilters' | 'documentById' | 'recentDocumentsByClient' | 'recentIssuedDocumentsByType';
+    Query: 'documents' | 'documentsByFilters' | 'documentById' | 'recentDocumentsByBusiness' | 'recentDocumentsByClient' | 'recentIssuedDocumentsByType';
     Mutation: 'insertDocument' | 'updateDocument' | 'deleteDocument' | 'uploadDocument' | 'batchUploadDocuments' | 'batchUploadDocumentsFromGoogleDrive' | 'closeDocument';
     Unprocessed: 'id' | 'image' | 'file' | 'documentType' | 'isReviewed';
     OtherDocument: 'id' | 'image' | 'file' | 'documentType' | 'isReviewed';
@@ -254,6 +254,7 @@ export namespace DocumentsModule {
       documents?: gm.Middleware[];
       documentsByFilters?: gm.Middleware[];
       documentById?: gm.Middleware[];
+      recentDocumentsByBusiness?: gm.Middleware[];
       recentDocumentsByClient?: gm.Middleware[];
       recentIssuedDocumentsByType?: gm.Middleware[];
     };