@solomonai/stripe-sync-graphql-sdk 0.0.1

package/src/__tests__/sdk.test.ts

@@ -0,0 +1,435 @@
+import { describe, it, expect } from 'vitest'
+import { createClient, ClientOptions } from '../index'
+import {
+  // Enums (runtime values)
+  SubscriptionStatus,
+  InvoiceStatus,
+  ChargeStatus,
+  EntityType,
+  Period,
+  PricingPlan,
+  PricingType,
+  PricingTiers,
+} from '../generated/graphql'
+import type {
+  Customer,
+  Subscription,
+  Invoice,
+  Charge,
+  Product,
+  Price,
+  SubscriptionItem,
+  MrrMetrics,
+  ChurnMetrics,
+  TenantUsage,
+  SyncResult,
+  Query,
+  Mutation,
+  PageInfo,
+  Scalars,
+} from '../generated/graphql'
+
+describe('GraphQL SDK', () => {
+  describe('createClient', () => {
+    it('should create a client with endpoint only', () => {
+      const client = createClient({
+        endpoint: 'https://api.example.com/graphql',
+      })
+
+      expect(client).toBeDefined()
+      expect(typeof client.request).toBe('function')
+    })
+
+    it('should create a client with headers', () => {
+      const client = createClient({
+        endpoint: 'https://api.example.com/graphql',
+        headers: {
+          'x-tenant-id': 'tenant-123',
+          'x-api-key': 'api-key-456',
+        },
+      })
+
+      expect(client).toBeDefined()
+    })
+
+    it('should create a client with timeout', () => {
+      const client = createClient({
+        endpoint: 'https://api.example.com/graphql',
+        timeout: 5000,
+      })
+
+      expect(client).toBeDefined()
+    })
+
+    it('should create a client with all options', () => {
+      const options: ClientOptions = {
+        endpoint: 'https://api.example.com/graphql',
+        headers: {
+          Authorization: 'Bearer token',
+          'x-tenant-id': 'tenant-123',
+        },
+        timeout: 10000,
+      }
+
+      const client = createClient(options)
+      expect(client).toBeDefined()
+    })
+  })
+
+  describe('Generated Types', () => {
+    describe('Scalars', () => {
+      it('should have correct scalar type definitions', () => {
+        // Type-level tests - these validate at compile time
+        const id: Scalars['ID']['output'] = 'test-id'
+        const str: Scalars['String']['output'] = 'test-string'
+        const bool: Scalars['Boolean']['output'] = true
+        const int: Scalars['Int']['output'] = 42
+        const float: Scalars['Float']['output'] = 3.14
+        const bigInt: Scalars['BigInt']['output'] = '9007199254740991'
+        const dateTime: Scalars['DateTime']['output'] = '2024-01-01T00:00:00Z'
+        const json: Scalars['JSON']['output'] = { key: 'value' }
+
+        expect(id).toBe('test-id')
+        expect(str).toBe('test-string')
+        expect(bool).toBe(true)
+        expect(int).toBe(42)
+        expect(float).toBe(3.14)
+        expect(bigInt).toBe('9007199254740991')
+        expect(dateTime).toBe('2024-01-01T00:00:00Z')
+        expect(json).toEqual({ key: 'value' })
+      })
+    })
+
+    describe('Customer type', () => {
+      it('should have correct shape', () => {
+        const customer: Customer = {
+          __typename: 'Customer',
+          id: 'cus_123',
+          email: 'test@example.com',
+          name: 'Test Customer',
+          balance: 0,
+          created: 1234567890,
+          currency: 'usd',
+          delinquent: false,
+          description: 'A test customer',
+          invoicePrefix: 'INV',
+          metadata: { key: 'value' },
+          phone: '+1234567890',
+          taxExempt: 'none',
+          lifetimeValue: '100000',
+          totalSpend: '50000',
+          churnRisk: 0.15,
+          address: null,
+          invoiceSettings: null,
+          invoices: [],
+          shipping: null,
+          subscriptions: [],
+        }
+
+        expect(customer.id).toBe('cus_123')
+        expect(customer.email).toBe('test@example.com')
+        expect(customer.__typename).toBe('Customer')
+      })
+
+      it('should allow nullable fields', () => {
+        const customer: Customer = {
+          __typename: 'Customer',
+          id: 'cus_123',
+        }
+
+        expect(customer.email).toBeUndefined()
+        expect(customer.name).toBeUndefined()
+      })
+    })
+
+    describe('Subscription type', () => {
+      it('should have correct shape', () => {
+        const subscription: Subscription = {
+          __typename: 'Subscription',
+          id: 'sub_123',
+          status: SubscriptionStatus.Active,
+          currentPeriodStart: 1234567890,
+          currentPeriodEnd: 1237246290,
+          cancelAtPeriodEnd: false,
+          created: 1234567890,
+          mrr: '2999',
+        }
+
+        expect(subscription.id).toBe('sub_123')
+        expect(subscription.status).toBe('active')
+        expect(subscription.mrr).toBe('2999')
+      })
+    })
+
+    describe('Invoice type', () => {
+      it('should have correct shape', () => {
+        const invoice: Invoice = {
+          __typename: 'Invoice',
+          id: 'in_123',
+          status: InvoiceStatus.Paid,
+          amountDue: '2999',
+          amountPaid: '2999',
+          amountRemaining: '0',
+          currency: 'usd',
+          paid: true,
+        }
+
+        expect(invoice.id).toBe('in_123')
+        expect(invoice.status).toBe('paid')
+        expect(invoice.paid).toBe(true)
+      })
+    })
+
+    describe('Charge type', () => {
+      it('should have correct shape', () => {
+        const charge: Charge = {
+          __typename: 'Charge',
+          id: 'ch_123',
+          amount: '2999',
+          currency: 'usd',
+          paid: true,
+          status: 'succeeded',
+          captured: true,
+        }
+
+        expect(charge.id).toBe('ch_123')
+        expect(charge.amount).toBe('2999')
+        expect(charge.paid).toBe(true)
+      })
+    })
+
+    describe('Product type', () => {
+      it('should have correct shape', () => {
+        const product: Product = {
+          __typename: 'Product',
+          id: 'prod_123',
+          name: 'Test Product',
+          active: true,
+          description: 'A test product',
+        }
+
+        expect(product.id).toBe('prod_123')
+        expect(product.name).toBe('Test Product')
+      })
+    })
+
+    describe('Price type', () => {
+      it('should have correct shape', () => {
+        const price: Price = {
+          __typename: 'Price',
+          id: 'price_123',
+          active: true,
+          currency: 'usd',
+          unitAmount: 2999,
+          type: PricingType.Recurring,
+          billingScheme: 'per_unit',
+        }
+
+        expect(price.id).toBe('price_123')
+        expect(price.unitAmount).toBe(2999)
+        expect(price.type).toBe('recurring')
+      })
+    })
+
+    describe('SubscriptionItem type', () => {
+      it('should have correct shape', () => {
+        const item: SubscriptionItem = {
+          __typename: 'SubscriptionItem',
+          id: 'si_123',
+          quantity: 5,
+          created: 1234567890,
+        }
+
+        expect(item.id).toBe('si_123')
+        expect(item.quantity).toBe(5)
+      })
+    })
+
+    describe('MRRMetrics type', () => {
+      it('should have correct shape', () => {
+        const metrics: MrrMetrics = {
+          __typename: 'MRRMetrics',
+          current: '100000',
+          previous: '90000',
+          growth: '10000',
+          growthRate: 11.11,
+          newMrr: '15000',
+          expansionMrr: '5000',
+          contractionMrr: '2000',
+          churnedMrr: '8000',
+        }
+
+        expect(metrics.current).toBe('100000')
+        expect(metrics.growthRate).toBe(11.11)
+      })
+    })
+
+    describe('ChurnMetrics type', () => {
+      it('should have correct shape', () => {
+        const metrics: ChurnMetrics = {
+          __typename: 'ChurnMetrics',
+          count: 5,
+          rate: 2.5,
+          period: 'MONTH',
+        }
+
+        expect(metrics.count).toBe(5)
+        expect(metrics.rate).toBe(2.5)
+      })
+    })
+
+    describe('TenantUsage type', () => {
+      it('should have correct shape', () => {
+        const usage: TenantUsage = {
+          __typename: 'TenantUsage',
+          webhookEventsThisPeriod: '1000',
+          apiCallsThisPeriod: '5000',
+          periodStart: '2024-01-01T00:00:00Z',
+          periodEnd: '2024-02-01T00:00:00Z',
+        }
+
+        expect(usage.webhookEventsThisPeriod).toBe('1000')
+        expect(usage.apiCallsThisPeriod).toBe('5000')
+      })
+    })
+
+    describe('SyncResult type', () => {
+      it('should have correct shape', () => {
+        const result: SyncResult = {
+          __typename: 'SyncResult',
+          success: true,
+          jobId: 'job_123',
+          message: 'Sync queued successfully',
+          entitiesQueued: 100,
+        }
+
+        expect(result.success).toBe(true)
+        expect(result.jobId).toBe('job_123')
+      })
+    })
+
+    describe('PageInfo type', () => {
+      it('should have correct shape', () => {
+        const pageInfo: PageInfo = {
+          __typename: 'PageInfo',
+          hasNextPage: true,
+          hasPreviousPage: false,
+          startCursor: 'cursor_start',
+          endCursor: 'cursor_end',
+        }
+
+        expect(pageInfo.hasNextPage).toBe(true)
+        expect(pageInfo.startCursor).toBe('cursor_start')
+      })
+    })
+  })
+
+  describe('Enums', () => {
+    it('should have SubscriptionStatus values', () => {
+      expect(SubscriptionStatus.Active).toBe('active')
+      expect(SubscriptionStatus.Canceled).toBe('canceled')
+      expect(SubscriptionStatus.Incomplete).toBe('incomplete')
+      expect(SubscriptionStatus.IncompleteExpired).toBe('incomplete_expired')
+      expect(SubscriptionStatus.PastDue).toBe('past_due')
+      expect(SubscriptionStatus.Trialing).toBe('trialing')
+      expect(SubscriptionStatus.Unpaid).toBe('unpaid')
+    })
+
+    it('should have InvoiceStatus values', () => {
+      expect(InvoiceStatus.Draft).toBe('draft')
+      expect(InvoiceStatus.Open).toBe('open')
+      expect(InvoiceStatus.Paid).toBe('paid')
+      expect(InvoiceStatus.Uncollectible).toBe('uncollectible')
+      expect(InvoiceStatus.Void).toBe('void')
+      expect(InvoiceStatus.Deleted).toBe('deleted')
+    })
+
+    it('should have ChargeStatus values', () => {
+      expect(ChargeStatus.Succeeded).toBe('succeeded')
+      expect(ChargeStatus.Pending).toBe('pending')
+      expect(ChargeStatus.Failed).toBe('failed')
+    })
+
+    it('should have EntityType values', () => {
+      expect(EntityType.Customer).toBe('CUSTOMER')
+      expect(EntityType.Subscription).toBe('SUBSCRIPTION')
+      expect(EntityType.Invoice).toBe('INVOICE')
+      expect(EntityType.Charge).toBe('CHARGE')
+      expect(EntityType.Product).toBe('PRODUCT')
+      expect(EntityType.Price).toBe('PRICE')
+      expect(EntityType.PaymentIntent).toBe('PAYMENT_INTENT')
+      expect(EntityType.PaymentMethod).toBe('PAYMENT_METHOD')
+    })
+
+    it('should have Period values', () => {
+      expect(Period.Day).toBe('DAY')
+      expect(Period.Week).toBe('WEEK')
+      expect(Period.Month).toBe('MONTH')
+      expect(Period.Quarter).toBe('QUARTER')
+      expect(Period.Year).toBe('YEAR')
+    })
+
+    it('should have PricingPlan values', () => {
+      expect(PricingPlan.Free).toBe('FREE')
+      expect(PricingPlan.Pro).toBe('PRO')
+      expect(PricingPlan.Enterprise).toBe('ENTERPRISE')
+    })
+
+    it('should have PricingType values', () => {
+      expect(PricingType.OneTime).toBe('one_time')
+      expect(PricingType.Recurring).toBe('recurring')
+    })
+
+    it('should have PricingTiers values', () => {
+      expect(PricingTiers.Graduated).toBe('graduated')
+      expect(PricingTiers.Volume).toBe('volume')
+    })
+  })
+
+  describe('Query type structure', () => {
+    it('should define all expected query fields', () => {
+      // Type-level validation - ensure Query has expected fields
+      type QueryFields = keyof Query
+      const expectedFields: QueryFields[] = [
+        '__typename',
+        '_version',
+        'customer',
+        'customers',
+        'subscription',
+        'subscriptions',
+        'invoice',
+        'invoices',
+        'charge',
+        'charges',
+        'product',
+        'products',
+        'price',
+        'prices',
+        'mrrMetrics',
+        'churnRate',
+        'tenantUsage',
+      ]
+
+      // This validates the type structure at compile time
+      expectedFields.forEach((field) => {
+        expect(typeof field).toBe('string')
+      })
+    })
+  })
+
+  describe('Mutation type structure', () => {
+    it('should define all expected mutation fields', () => {
+      type MutationFields = keyof Mutation
+      const expectedFields: MutationFields[] = [
+        '__typename',
+        '_noop',
+        'triggerSync',
+        'syncSingleEntity',
+      ]
+
+      expectedFields.forEach((field) => {
+        expect(typeof field).toBe('string')
+      })
+    })
+  })
+})

package/src/generated/gql.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import * as types from './graphql'
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
+
+const documents: DocumentNode<any, any>[] = []
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = graphql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export function graphql(source: string): unknown
+
+export function graphql(source: string): DocumentNode<any, any> {
+  return (
+    (documents as unknown as Record<string, DocumentNode<any, any>>)[source] ??
+    ({} as DocumentNode<any, any>)
+  )
+}
+
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> =
+  TDocumentNode extends DocumentNode<infer TType, any> ? TType : never