@merchi/sdk 1.40.2

package/src/entities/agent_skill.ts

@@ -0,0 +1,99 @@
+import { Entity } from '../entity.js';
+import { RequestOptions } from '../request.js';
+import { AgentSkillVersion } from './agent_skill_version.js';
+import { Category } from './category.js';
+import { Domain } from './domain.js';
+import { Product } from './product.js';
+
+interface CreateDraftOptions {
+  contentMd?: string;
+}
+
+export class AgentSkill extends Entity {
+  protected static resourceName = 'agent_skills';
+  protected static singularName = 'agentSkill';
+  protected static pluralName = 'agentSkills';
+  protected static primaryKey = 'id';
+
+  @AgentSkill.property()
+  public id?: string;
+
+  @AgentSkill.property()
+  public slug?: string;
+
+  @AgentSkill.property()
+  public title?: string;
+
+  @AgentSkill.property()
+  public scope?: 'global' | 'domain' | 'domain_category' | 'domain_product';
+
+  @AgentSkill.property({ type: Domain })
+  public domain?: Domain | null;
+
+  @AgentSkill.property({ type: Category })
+  public category?: Category | null;
+
+  @AgentSkill.property({ type: Product })
+  public product?: Product | null;
+
+  @AgentSkill.property()
+  public description?: string | null;
+
+  @AgentSkill.property()
+  public priority?: number;
+
+  @AgentSkill.property({ type: Date })
+  public createdAt?: Date | null;
+
+  @AgentSkill.property({ type: Date })
+  public disabledAt?: Date | null;
+
+  @AgentSkill.property()
+  public currentDraftVersionId?: string | null;
+
+  @AgentSkill.property()
+  public currentPublishedVersionId?: string | null;
+
+  @AgentSkill.property({ arrayType: 'AgentSkillVersion' })
+  public versions?: AgentSkillVersion[];
+
+  public createDraftVersion = (options?: CreateDraftOptions) => {
+    const resource = `/agent_skills/${this.id}/versions/`;
+    const fetchOptions: RequestOptions = { method: 'POST' };
+    if (options && options.contentMd) {
+      const body = new FormData();
+      body.set('contentMd', options.contentMd);
+      fetchOptions.body = body;
+    }
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      const version = new this.merchi.AgentSkillVersion();
+      version.fromJson(data.agentSkillVersion);
+      this.currentDraftVersionId = version.id;
+      return version;
+    });
+  };
+
+  public disable = () => {
+    const resource = `/agent_skills/${this.id}/disable/`;
+    const fetchOptions: RequestOptions = { method: 'POST' };
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      this.fromJson(data.agentSkill);
+      return this;
+    });
+  };
+
+  public enable = () => {
+    const resource = `/agent_skills/${this.id}/enable/`;
+    const fetchOptions: RequestOptions = { method: 'POST' };
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      this.fromJson(data.agentSkill);
+      return this;
+    });
+  };
+
+  public getVersionDiff = (versionId: string) => {
+    const resource = `/agent_skills/${this.id}/versions/${versionId}/diff/`;
+    const fetchOptions: RequestOptions = { method: 'GET' };
+    return this.merchi.authenticatedFetch(resource, fetchOptions);
+  };
+}

package/src/entities/agent_skill_approval.ts

@@ -0,0 +1,26 @@
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+
+export class AgentSkillApproval extends Entity {
+  protected static resourceName = 'agent_skill_approvals';
+  protected static singularName = 'agentSkillApproval';
+  protected static pluralName = 'agentSkillApprovals';
+
+  @AgentSkillApproval.property()
+  public id?: string;
+
+  @AgentSkillApproval.property()
+  public skillVersionId?: string;
+
+  @AgentSkillApproval.property({ type: User })
+  public superUser?: User | null;
+
+  @AgentSkillApproval.property()
+  public decision?: 'approved' | 'rejected';
+
+  @AgentSkillApproval.property()
+  public comment?: string | null;
+
+  @AgentSkillApproval.property({ type: Date })
+  public createdAt?: Date | null;
+}

package/src/entities/agent_skill_version.ts

@@ -0,0 +1,64 @@
+import { Entity } from '../entity.js';
+import { RequestOptions } from '../request.js';
+
+export class AgentSkillVersion extends Entity {
+  protected static resourceName = 'agent_skill_versions';
+  protected static singularName = 'agentSkillVersion';
+  protected static pluralName = 'agentSkillVersions';
+
+  @AgentSkillVersion.property()
+  public id?: string;
+
+  @AgentSkillVersion.property()
+  public skillId?: string;
+
+  @AgentSkillVersion.property()
+  public versionNumber?: number;
+
+  @AgentSkillVersion.property()
+  public contentMd?: string;
+
+  @AgentSkillVersion.property()
+  public contentHash?: string;
+
+  @AgentSkillVersion.property()
+  public status?: string;
+
+  @AgentSkillVersion.property({ type: Date })
+  public requestedAt?: Date | null;
+
+  @AgentSkillVersion.property({ type: Date })
+  public publishedAt?: Date | null;
+
+  @AgentSkillVersion.property({ type: Date })
+  public disabledAt?: Date | null;
+
+  public submit = (skillId: string) => {
+    const resource = `/agent_skills/${skillId}/versions/${this.id}/submit/`;
+    const fetchOptions: RequestOptions = { method: 'POST' };
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      this.fromJson(data.agentSkillVersion);
+      return this;
+    });
+  };
+
+  public approve = (skillId: string, comment: string) => {
+    const resource = `/agent_skills/${skillId}/versions/${this.id}/approve/`;
+    const fetchOptions: RequestOptions = { method: 'POST', body: new FormData() };
+    (fetchOptions.body as FormData).set('comment', comment);
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      this.fromJson(data.agentSkillVersion);
+      return this;
+    });
+  };
+
+  public reject = (skillId: string, comment: string) => {
+    const resource = `/agent_skills/${skillId}/versions/${this.id}/reject/`;
+    const fetchOptions: RequestOptions = { method: 'POST', body: new FormData() };
+    (fetchOptions.body as FormData).set('comment', comment);
+    return this.merchi.authenticatedFetch(resource, fetchOptions).then((data: any) => {
+      this.fromJson(data.agentSkillVersion);
+      return this;
+    });
+  };
+}

package/src/entities/agent_token_analytics.ts

@@ -0,0 +1,49 @@
+export interface AgentTokenAnalyticsSummary {
+  percentageDifference?: number | null;
+  totals?: number;
+  previousTotals?: number;
+}
+
+export interface AgentTokenAnalyticsTimeseries {
+  dates?: string[];
+  totalTokens?: number[];
+  promptTokens?: number[];
+  completionTokens?: number[];
+}
+
+export interface ProfileAnalyticsSummaryMetric {
+  percentageDifference?: number | null;
+  totals?: number | { total?: number; currency?: string };
+  previousTotals?: number | { total?: number; currency?: string };
+}
+
+export interface CompanyAnalyticsResponse {
+  totalJobs?: ProfileAnalyticsSummaryMetric;
+  completedJobs?: ProfileAnalyticsSummaryMetric;
+  totalInvoices?: ProfileAnalyticsSummaryMetric;
+  paymentsReceived?: ProfileAnalyticsSummaryMetric;
+  agentTokenUsage?: AgentTokenAnalyticsSummary;
+}
+
+export interface DomainAnalyticsResponse extends CompanyAnalyticsResponse {}
+
+export interface AgentTokenUsageRecordPayload {
+  companyId?: number;
+  domainId?: number;
+  promptTokens?: number;
+  completionTokens?: number;
+  totalTokens?: number;
+  sourceType?: string;
+  modelName?: string;
+  agentConversationId?: number;
+  supportConversationId?: number;
+}
+
+export interface AgentTokenUsageRecordResponse {
+  agentTokenUsage?: {
+    id?: number;
+    companyId?: number;
+    domainId?: number;
+    totalTokens?: number;
+  };
+}

package/src/entities/agent_token_usage.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can record agent token usage', () => {
+  const merchi = new Merchi();
+  const usage = new merchi.AgentTokenUsage();
+  expect(usage).toBeTruthy();
+});

package/src/entities/agent_token_usage.ts

@@ -0,0 +1,88 @@
+import { Entity } from '../entity.js';
+import { Company } from './company.js';
+import { Domain } from './domain.js';
+import { User } from './user.js';
+import { AgentConversation } from './agent_conversation.js';
+import { SupportConversation } from './support_conversation.js';
+import type {
+  AgentTokenUsageRecordPayload,
+  AgentTokenUsageRecordResponse,
+} from './agent_token_analytics.js';
+import type { RequestOptions } from '../request.js';
+
+export class AgentTokenUsage extends Entity {
+  protected static resourceName = 'agent_token_usage';
+  protected static singularName = 'agentTokenUsage';
+  protected static pluralName = 'agentTokenUsage';
+
+  @AgentTokenUsage.property()
+  public id?: number;
+
+  @AgentTokenUsage.property({type: Date})
+  public createdAt?: Date | null;
+
+  @AgentTokenUsage.property()
+  public companyId?: number;
+
+  @AgentTokenUsage.property()
+  public domainId?: number;
+
+  @AgentTokenUsage.property()
+  public userId?: number;
+
+  @AgentTokenUsage.property({type: Company})
+  public company?: Company | null;
+
+  @AgentTokenUsage.property({type: Domain})
+  public domain?: Domain | null;
+
+  @AgentTokenUsage.property({type: User})
+  public user?: User | null;
+
+  @AgentTokenUsage.property({type: AgentConversation})
+  public agentConversation?: AgentConversation | null;
+
+  @AgentTokenUsage.property({type: SupportConversation})
+  public supportConversation?: SupportConversation | null;
+
+  @AgentTokenUsage.property()
+  public agentConversationId?: number;
+
+  @AgentTokenUsage.property()
+  public supportConversationId?: number;
+
+  @AgentTokenUsage.property()
+  public sourceType?: string;
+
+  @AgentTokenUsage.property()
+  public modelName?: string;
+
+  @AgentTokenUsage.property()
+  public promptTokens?: number;
+
+  @AgentTokenUsage.property()
+  public completionTokens?: number;
+
+  @AgentTokenUsage.property()
+  public totalTokens?: number;
+
+  public static record = (
+    payload: AgentTokenUsageRecordPayload,
+    fetchOptions?: RequestOptions
+  ): Promise<AgentTokenUsageRecordResponse> => {
+    const Constructor = this as typeof AgentTokenUsage;
+    const fetchOpts: RequestOptions = {
+      ...(fetchOptions || {}),
+      method: 'POST',
+      body: JSON.stringify(payload),
+      headers: {
+        ...(fetchOptions?.headers || {}),
+        'Content-Type': 'application/json',
+      },
+    };
+    return Constructor.merchi.authenticatedFetch(
+      '/agent_token_usage/',
+      fetchOpts
+    ) as Promise<AgentTokenUsageRecordResponse>;
+  };
+}

package/src/entities/assignment.test.ts

@@ -0,0 +1,39 @@
+import { Merchi } from '../merchi.js';
+import { setup, mockFetch } from '../test_util.js';
+
+setup();
+
+test('can make Assignment', () => {
+  const merchi = new Merchi();
+  const assignment = new merchi.Assignment();
+  expect(assignment).toBeTruthy();
+});
+
+test('can generate new invoice', () => {
+  mockFetch(true, {'id': 1, 'totalCost': 100}, 200);
+
+  const merchi = new Merchi();
+  const assignment = new merchi.Assignment();
+  assignment.id = 1;
+  assignment.generateInvoice().then(invoice => {
+    expect(invoice.totalCost).toEqual(100);
+    expect(invoice.id).toEqual(1);
+  });
+});
+
+test('can add to invoice', () => {
+  const fetch = mockFetch(true, {'id': 2, 'totalCost': 100}, 200);
+  const merchi = new Merchi();
+  const assignment = new merchi.Assignment();
+  assignment.id = 1;
+  assignment.generateInvoice({addToInvoice: 2}).then(invoice => {
+    expect(invoice.totalCost).toEqual(100);
+    expect(invoice.id).toEqual(2);
+  });
+
+  const correct = [['add_to_invoice', '2']];
+  expect(
+    Array.from(fetch.mock.calls[0][1]['query'])
+  ).toEqual(correct);
+});
+

package/src/entities/assignment.ts

@@ -0,0 +1,99 @@
+import { Entity } from '../entity.js';
+import { Quote } from './quote.js';
+import { MerchiFile } from './file.js';
+import { Job } from './job.js';
+import { Notification } from './notification.js';
+import { ProductionComment } from './production_comment.js';
+import { Reminder } from './reminder.js';
+import { Shipment } from './shipment.js';
+import { SupplyDomain } from './supply_domain.js';
+import { User } from './user.js';
+import { RequestOptions } from '../request.js';
+
+interface GenerateInvoiceProps {
+  addToInvoice? : number;
+}
+
+export class Assignment extends Entity {
+  protected static resourceName = 'assignments';
+  protected static singularName = 'assignment';
+  protected static pluralName = 'assignments';
+
+  @Assignment.property({type: Date})
+  public archived?: Date | null;
+
+  @Assignment.property()
+  public id?: number;
+
+  @Assignment.property({type: Date})
+  public managerAccepts?: Date | null;
+
+  @Assignment.property({type: Date})
+  public supplierRefused?: Date | null;
+
+  @Assignment.property()
+  public needsDrafting?: boolean;
+
+  @Assignment.property()
+  public needsShipping?: boolean;
+
+  @Assignment.property()
+  public productionDeadline?: Date;
+
+  @Assignment.property()
+  public assignmentDeadline?: Date;
+
+  @Assignment.property({type: String})
+  public notes?: string | null;
+
+  @Assignment.property({type: 'Job'})
+  public job?: Job | null;
+
+  @Assignment.property({type: 'Job'})
+  public supplyJob?: Job | null;
+
+  @Assignment.property({type: User})
+  public supplier?: User | null;
+
+  @Assignment.property({type: Quote})
+  public quote?: Quote | null;
+
+  @Assignment.property()
+  public quoteTotalCost?: number;
+
+  @Assignment.property({arrayType: 'ProductionComment'})
+  public comments?: ProductionComment[];
+
+  @Assignment.property({type: Shipment})
+  public shipment?: Shipment | null;
+
+  @Assignment.property({type: SupplyDomain})
+  public supplyDomain?: SupplyDomain | null;
+
+  @Assignment.property({arrayType: 'Notification'})
+  public notifications?: Notification[];
+
+  @Assignment.property({arrayType: 'Reminder'})
+  public reminders?: Reminder[];
+
+  @Assignment.property({arrayType: 'MerchiFile'})
+  public productionFiles?: MerchiFile[];
+
+  public generateInvoice = (props?: GenerateInvoiceProps) => {
+    const resource = `/generate-invoice-for-assignment/${this.id}/`;
+    const fetchOptions: RequestOptions = {method: 'POST'};
+    fetchOptions.query = [];
+
+    if (props && props.addToInvoice) {
+      fetchOptions.query.push(['add_to_invoice', String(props.addToInvoice!)]);
+    }
+
+    return this.merchi.authenticatedFetch(resource, fetchOptions).
+      then((data: any) => {
+        const invoice = new this.merchi.Invoice();
+        invoice.fromJson(data);
+        return invoice;
+      });
+  };
+
+}

package/src/entities/automatic_payment_relationship.test.ts

@@ -0,0 +1,8 @@
+import { Merchi } from '../merchi.js';
+
+test('can make AutomaticPaymentRelationship', () => {
+  const merchi = new Merchi();
+  const automaticPaymentRelationship =
+    new merchi.AutomaticPaymentRelationship();
+  expect(automaticPaymentRelationship).toBeTruthy();
+});

package/src/entities/automatic_payment_relationship.ts

@@ -0,0 +1,29 @@
+import { Company } from './company.js';
+import { Entity } from '../entity.js';
+
+export class AutomaticPaymentRelationship extends Entity {
+  protected static resourceName = 'automatic_payment_relationships';
+  protected static singularName = 'automaticPaymentRelationship';
+  protected static pluralName = 'automaticPaymentRelationships';
+
+  @AutomaticPaymentRelationship.property({type: Date})
+  public archived?: Date | null;
+
+  @AutomaticPaymentRelationship.property()
+  public id?: number;
+
+  @AutomaticPaymentRelationship.property()
+  public creationDate?: Date;
+
+  @AutomaticPaymentRelationship.property()
+  public allowPostPayment?: boolean;
+
+  @AutomaticPaymentRelationship.property({type: Company})
+  public companyCustomer?: Company;
+
+  @AutomaticPaymentRelationship.property({type: Company})
+  public companySupplier?: Company;
+
+  @AutomaticPaymentRelationship.property({type: String})
+  public stripeCustomerId?: string;
+}

package/src/entities/bank.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make Bank', () => {
+  const merchi = new Merchi();
+  const bank = new merchi.Bank();
+  expect(bank).toBeTruthy();
+});

package/src/entities/bank.ts

@@ -0,0 +1,45 @@
+import { Address } from './address.js';
+import { Company } from './company.js';
+import { Entity } from '../entity.js';
+
+export class Bank extends Entity {
+  protected static resourceName = 'banks';
+  protected static singularName = 'bank';
+  protected static pluralName = 'banks';
+
+  @Bank.property({type: Date})
+  public archived?: Date | null;
+
+  @Bank.property()
+  public id?: number;
+
+  @Bank.property()
+  public default?: boolean;
+
+  @Bank.property()
+  public bankName?: string;
+
+  @Bank.property()
+  public accountNumber?: string;
+
+  @Bank.property()
+  public accountName?: string;
+
+  @Bank.property({type: String})
+  public bsb?: string | null;
+
+  @Bank.property({type: String})
+  public swiftCode?: string | null;
+
+  @Bank.property({type: String})
+  public iban?: string | null;
+
+  @Bank.property({type: String})
+  public bankCode?: string | null;
+
+  @Bank.property({type: 'Address'})
+  public bankAddress?: Address | null;
+
+  @Bank.property()
+  public company?: Company;
+}

package/src/entities/cart.test.ts

@@ -0,0 +1,57 @@
+import { Merchi } from '../merchi.js';
+import { setup, mockFetch } from '../test_util.js';
+
+setup();
+
+test('can make Cart', () => {
+  const merchi = new Merchi();
+  const cart = new merchi.Cart();
+  expect(cart).toBeTruthy();
+});
+
+test('cart token supported by merchi', () => {
+  const merchi = new Merchi(undefined, undefined, undefined, 'c');
+  const correct = [['skip_rights', 'y'], ['cart_token', 'c']];
+  const fetch = mockFetch(true, {'invoice': {'id': 1}}, 200);
+  const invocation = merchi.Invoice.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});
+
+test('requiresShipment', () => {
+  const merchi = new Merchi();
+  const cart = new merchi.Cart();
+  expect(cart.requiresShipment).toThrow();
+  cart.cartItems = [];
+  expect(cart.requiresShipment()).toBe(false);
+  cart.cartItems = [new merchi.CartItem()];
+  cart.cartItems[0].product = new merchi.Product();
+  cart.cartItems[0].product.needsShipping = true;
+  expect(cart.requiresShipment()).toBe(true);
+  cart.cartItems[0].product.needsShipping = false;
+  expect(cart.requiresShipment()).toBe(false);
+});
+
+test('pass cookie tokens to query string', () => {
+  const cookie = 'cart_token=c;';
+  Object.defineProperty(document, 'cookie', {
+    get: jest.fn().mockImplementation(() => { return cookie; }),
+    set: jest.fn().mockImplementation(() => {}),
+  });
+  const correct = [
+    ['skip_rights', 'y'],
+    ['cart_token', 'c'],
+  ];
+  const fetch = mockFetch(true, {'cart': {'id': 1}}, 200);
+  const merchi = new Merchi();
+  const invocation = merchi.Cart.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});
+
+test('preserves server payment engine hint', () => {
+  const merchi = new Merchi();
+  const entity = new merchi.Cart();
+  entity.fromJson({ id: 1, stripePaymentEngine: 'wallet' });
+  expect(entity.toJson()).toMatchObject({ stripePaymentEngine: 'wallet' });
+});