@posthog/core 1.0.2 → 1.2.0

package/src/__tests__/posthog.flush.spec.ts

@@ -0,0 +1,237 @@
+import { delay, waitForPromises, createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+import { PostHogPersistedProperty } from '@/types'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  describe('flush', () => {
+    beforeEach(() => {
+      jest.useFakeTimers()
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
+        flushAt: 5,
+        fetchRetryCount: 3,
+        fetchRetryDelay: 100,
+        preloadFeatureFlags: false,
+      })
+    })
+
+    it("doesn't fail when queue is empty", async () => {
+      jest.useRealTimers()
+      await expect(posthog.flush()).resolves.not.toThrow()
+      expect(mocks.fetch).not.toHaveBeenCalled()
+    })
+
+    it('flush messages once called', async () => {
+      const successfulMessages: any[] = []
+
+      mocks.fetch.mockImplementation(async (_, options) => {
+        const batch = JSON.parse((options.body || '') as string).batch
+
+        successfulMessages.push(...batch)
+        return Promise.resolve({
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        })
+      })
+
+      posthog.capture('test-event-1')
+      posthog.capture('test-event-2')
+      posthog.capture('test-event-3')
+      expect(mocks.fetch).not.toHaveBeenCalled()
+      await expect(posthog.flush()).resolves.not.toThrow()
+      expect(mocks.fetch).toHaveBeenCalled()
+      expect(successfulMessages).toMatchObject([
+        { event: 'test-event-1' },
+        { event: 'test-event-2' },
+        { event: 'test-event-3' },
+      ])
+    })
+
+    it.each([400, 500])('responds with an error after retries with %s error', async (status) => {
+      mocks.fetch.mockImplementation(() => {
+        return Promise.resolve({
+          status: status,
+          text: async () => 'err',
+          json: async () => ({ status: 'err' }),
+        })
+      })
+      posthog.capture('test-event-1')
+
+      const time = Date.now()
+      jest.useRealTimers()
+      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+      expect(mocks.fetch).toHaveBeenCalledTimes(4)
+      expect(Date.now() - time).toBeGreaterThan(300)
+      expect(Date.now() - time).toBeLessThan(500)
+    })
+
+    it('responds with an error after retries with network error ', async () => {
+      mocks.fetch.mockImplementation(() => {
+        return Promise.reject(new Error('network problems'))
+      })
+      posthog.capture('test-event-1')
+
+      const time = Date.now()
+      jest.useRealTimers()
+      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchNetworkError')
+      expect(mocks.fetch).toHaveBeenCalledTimes(4)
+      expect(Date.now() - time).toBeGreaterThan(300)
+      expect(Date.now() - time).toBeLessThan(500)
+    })
+
+    it('skips when client is disabled', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 2 })
+
+      posthog.capture('test-event-1')
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(0)
+      posthog.capture('test-event-2')
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+      posthog.optOut()
+      posthog.capture('test-event-3')
+      posthog.capture('test-event-4')
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('does not get stuck in a loop when new events are added while flushing', async () => {
+      jest.useRealTimers()
+      mocks.fetch.mockImplementation(async () => {
+        posthog.capture('another-event')
+        await delay(10)
+        return Promise.resolve({
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        })
+      })
+
+      posthog.capture('test-event-1')
+      await posthog.flush()
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('should flush all events even if larger than batch size', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
+
+      const successfulMessages: any[] = []
+
+      mocks.fetch.mockImplementation(async (_, options) => {
+        const batch = JSON.parse((options.body || '') as string).batch
+
+        successfulMessages.push(...batch)
+        return Promise.resolve({
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        })
+      })
+
+      posthog['maxBatchSize'] = 2 // a bit contrived because usually maxBatchSize >= flushAt
+      posthog.capture('test-event-1')
+      posthog.capture('test-event-2')
+      posthog.capture('test-event-3')
+      posthog.capture('test-event-4')
+      await expect(posthog.flush()).resolves.not.toThrow()
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      expect(successfulMessages).toMatchObject([
+        { event: 'test-event-1' },
+        { event: 'test-event-2' },
+        { event: 'test-event-3' },
+        { event: 'test-event-4' },
+      ])
+    })
+
+    it('should reduce the batch size without dropping events if received 413', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
+      const successfulMessages: any[] = []
+
+      mocks.fetch.mockImplementation(async (_, options) => {
+        const batch = JSON.parse((options.body || '') as string).batch
+
+        if (batch.length > 1) {
+          return Promise.resolve({
+            status: 413,
+            text: () => Promise.resolve('Content Too Large'),
+            json: () => Promise.resolve({ status: 'Content Too Large' }),
+          })
+        } else {
+          successfulMessages.push(...batch)
+          return Promise.resolve({
+            status: 200,
+            text: () => Promise.resolve('ok'),
+            json: () => Promise.resolve({ status: 'ok' }),
+          })
+        }
+      })
+
+      posthog.capture('test-event-1')
+      posthog.capture('test-event-2')
+      posthog.capture('test-event-3')
+      posthog.capture('test-event-4')
+      await expect(posthog.flush()).resolves.not.toThrow()
+      expect(successfulMessages).toMatchObject([
+        { event: 'test-event-1' },
+        { event: 'test-event-2' },
+        { event: 'test-event-3' },
+        { event: 'test-event-4' },
+      ])
+      expect(mocks.fetch).toHaveBeenCalledTimes(6) // 2 failures with size 4 then 2, then 4 successes with size 1
+    })
+
+    it('should treat a 413 at batchSize 1 as a regular error', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
+
+      mocks.fetch.mockImplementation(async () => {
+        return Promise.resolve({
+          status: 413,
+          text: () => Promise.resolve('Content Too Large'),
+          json: () => Promise.resolve({ status: 'Content Too Large' }),
+        })
+      })
+
+      posthog.capture('test-event-1')
+      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('should stop at first error', async () => {
+      jest.useRealTimers()
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10, fetchRetryDelay: 1 })
+      posthog['maxBatchSize'] = 1 // a bit contrived because usually maxBatchSize >= flushAt
+      const successfulMessages: any[] = []
+
+      mocks.fetch.mockImplementation(async (_, options) => {
+        const batch = JSON.parse((options.body || '') as string).batch
+
+        if (batch.some((msg: any) => msg.event.includes('cursed'))) {
+          return Promise.resolve({
+            status: 500,
+            text: () => Promise.resolve('Cursed'),
+            json: () => Promise.resolve({ status: 'Cursed' }),
+          })
+        } else {
+          successfulMessages.push(...batch)
+          return Promise.resolve({
+            status: 200,
+            text: () => Promise.resolve('ok'),
+            json: () => Promise.resolve({ status: 'ok' }),
+          })
+        }
+      })
+
+      posthog.capture('test-event-1')
+      posthog.capture('cursed-event-2')
+      posthog.capture('test-event-3')
+
+      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+      expect(successfulMessages).toMatchObject([{ event: 'test-event-1' }])
+      expect(mocks.storage.getItem(PostHogPersistedProperty.Queue)).toMatchObject([
+        { message: { event: 'test-event-3' } },
+      ])
+    })
+  })
+})

package/src/__tests__/posthog.gdpr.spec.ts

@@ -0,0 +1,50 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 5 })
+  })
+
+  describe('optOut', () => {
+    it('should be optedIn by default', async () => {
+      expect(posthog.optedOut).toEqual(false)
+    })
+
+    it('should be able to init disabled', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
+      expect(posthog.optedOut).toEqual(true)
+    })
+
+    it('should opt in/out when called', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
+      posthog.optOut()
+      expect(posthog.optedOut).toEqual(true)
+      posthog.optIn()
+      expect(posthog.optedOut).toEqual(false)
+    })
+
+    it('should persist enabled state when called', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(undefined)
+      posthog.optOut()
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(true)
+      posthog.optIn()
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(false)
+    })
+
+    it('should start in the correct state', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false }, (mocks) => {
+        mocks.storage.setItem(PostHogPersistedProperty.OptedOut, true)
+      })
+
+      expect(posthog.optedOut).toEqual(true)
+    })
+  })
+})

package/src/__tests__/posthog.groups.spec.ts

@@ -0,0 +1,96 @@
+import {
+  createTestClient,
+  PostHogCoreTestClient,
+  PostHogCoreTestClientMocks,
+  parseBody,
+  waitForPromises,
+} from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  beforeEach(() => {
+    jest.useFakeTimers()
+    jest.setSystemTime(new Date('2022-01-01'))
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
+  })
+
+  describe('groups', () => {
+    it('should store groups as persisted props', () => {
+      const groups = { posthog: 'team-1', other: 'key-2' }
+      posthog.groups(groups)
+
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('props', {
+        $groups: groups,
+      })
+    })
+  })
+
+  describe('group', () => {
+    it('should store group as persisted props', () => {
+      const groups = { posthog: 'team-1' }
+      posthog.groups(groups)
+      posthog.group('other', 'foo')
+      posthog.group('posthog', 'team-2')
+
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('props', {
+        $groups: {
+          posthog: 'team-2',
+          other: 'foo',
+        },
+      })
+    })
+
+    it('should call groupIdentify if including props', async () => {
+      posthog.group('other', 'team', { foo: 'bar' })
+      await waitForPromises()
+
+      expect(mocks.fetch).toHaveBeenCalledTimes(2) // 1 for flags, 1 for groupIdentify
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        batch: [
+          {
+            event: '$groupidentify',
+            distinct_id: posthog.getDistinctId(),
+            properties: {
+              $group_type: 'other',
+              $group_key: 'team',
+              $group_set: { foo: 'bar' },
+            },
+            type: 'capture',
+          },
+        ],
+      })
+    })
+  })
+
+  describe('groupIdentify', () => {
+    it('should identify group', async () => {
+      posthog.groupIdentify('posthog', 'team-1', { analytics: true })
+      await waitForPromises()
+
+      expect(parseBody(mocks.fetch.mock.calls[0])).toMatchObject({
+        api_key: 'TEST_API_KEY',
+        batch: [
+          {
+            event: '$groupidentify',
+            distinct_id: posthog.getDistinctId(),
+            library: 'posthog-core-tests',
+            library_version: '2.0.0-alpha',
+            properties: {
+              $lib: 'posthog-core-tests',
+              $lib_version: '2.0.0-alpha',
+              $group_type: 'posthog',
+              $group_key: 'team-1',
+              $group_set: { analytics: true },
+            },
+            timestamp: '2022-01-01T00:00:00.000Z',
+            type: 'capture',
+          },
+        ],
+      })
+    })
+  })
+})

package/src/__tests__/posthog.identify.spec.ts

@@ -0,0 +1,194 @@
+import {
+  parseBody,
+  waitForPromises,
+  createTestClient,
+  PostHogCoreTestClient,
+  PostHogCoreTestClientMocks,
+} from '@/testing'
+import { PostHogPersistedProperty } from '@/types'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2022-01-01'))
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
+  })
+
+  describe('identify', () => {
+    // Identify also triggers a subsequent flags call so we should expect 2 calls
+    it('should send an $identify event', async () => {
+      posthog.identify('id-1', { foo: 'bar' })
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        api_key: 'TEST_API_KEY',
+        batch: [
+          {
+            event: '$identify',
+            distinct_id: posthog.getDistinctId(),
+            library: 'posthog-core-tests',
+            library_version: '2.0.0-alpha',
+            properties: {
+              $lib: 'posthog-core-tests',
+              $lib_version: '2.0.0-alpha',
+              $anon_distinct_id: expect.any(String),
+              $session_id: expect.any(String),
+              $set: {
+                foo: 'bar',
+              },
+            },
+            timestamp: expect.any(String),
+            uuid: expect.any(String),
+            type: 'identify',
+          },
+        ],
+        sent_at: expect.any(String),
+      })
+    })
+
+    it('should send an $identify with $set and $set_once event', async () => {
+      posthog.identify('id-1', {
+        $set: {
+          foo: 'bar',
+        },
+        $set_once: {
+          vip: true,
+        },
+      })
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        api_key: 'TEST_API_KEY',
+        batch: [
+          {
+            event: '$identify',
+            distinct_id: posthog.getDistinctId(),
+            library: 'posthog-core-tests',
+            library_version: '2.0.0-alpha',
+            properties: {
+              $lib: 'posthog-core-tests',
+              $lib_version: '2.0.0-alpha',
+              $anon_distinct_id: expect.any(String),
+              $session_id: expect.any(String),
+              $set: {
+                foo: 'bar',
+              },
+              $set_once: {
+                vip: true,
+              },
+            },
+            timestamp: expect.any(String),
+            uuid: expect.any(String),
+            type: 'identify',
+          },
+        ],
+        sent_at: expect.any(String),
+      })
+    })
+
+    it('should send an $identify with $set_once event', async () => {
+      posthog.identify('id-1', {
+        foo: 'bar',
+        $set_once: {
+          vip: true,
+        },
+      })
+      await waitForPromises()
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        api_key: 'TEST_API_KEY',
+        batch: [
+          {
+            event: '$identify',
+            distinct_id: posthog.getDistinctId(),
+            library: 'posthog-core-tests',
+            library_version: '2.0.0-alpha',
+            properties: {
+              $lib: 'posthog-core-tests',
+              $lib_version: '2.0.0-alpha',
+              $anon_distinct_id: expect.any(String),
+              $session_id: expect.any(String),
+              $set: {
+                foo: 'bar',
+              },
+              $set_once: {
+                vip: true,
+              },
+            },
+            timestamp: expect.any(String),
+            uuid: expect.any(String),
+            type: 'identify',
+          },
+        ],
+        sent_at: expect.any(String),
+      })
+    })
+
+    it('should include anonymous ID if set', async () => {
+      posthog.identify('id-1', { foo: 'bar' })
+      await waitForPromises()
+
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        batch: [
+          {
+            distinct_id: posthog.getDistinctId(),
+            properties: {
+              $anon_distinct_id: expect.any(String),
+            },
+          },
+        ],
+      })
+    })
+
+    it('should update distinctId if different', () => {
+      const distinctId = posthog.getDistinctId()
+      posthog.identify('id-1', { foo: 'bar' })
+
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('anonymous_id', distinctId)
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('distinct_id', 'id-1')
+    })
+
+    it('should use existing distinctId from storage', async () => {
+      mocks.storage.setItem(PostHogPersistedProperty.AnonymousId, 'my-old-value')
+      mocks.storage.setItem.mockClear()
+      posthog.identify('id-1', { foo: 'bar' })
+      await waitForPromises()
+
+      // One call exists for the queueing, one for persisting distinct id
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('distinct_id', 'id-1')
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+      const batchCall = mocks.fetch.mock.calls[1]
+      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
+      expect(parseBody(batchCall)).toMatchObject({
+        batch: [
+          {
+            distinct_id: 'id-1',
+            properties: {
+              $anon_distinct_id: 'my-old-value',
+            },
+          },
+        ],
+      })
+    })
+
+    it('should not update stored properties if distinct_id the same', () => {
+      mocks.storage.setItem(PostHogPersistedProperty.DistinctId, 'id-1')
+      mocks.storage.setItem.mockClear()
+      posthog.identify('id-1', { foo: 'bar' })
+      expect(mocks.storage.setItem).not.toHaveBeenCalledWith('distinct_id', 'id-1')
+    })
+  })
+})

package/src/__tests__/posthog.init.spec.ts

@@ -0,0 +1,110 @@
+import { createTestClient, waitForPromises, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
+  })
+
+  describe('init', () => {
+    it('should initialise', () => {
+      expect(posthog.optedOut).toEqual(false)
+    })
+
+    it('should throw if missing api key', () => {
+      expect(() => createTestClient(undefined as unknown as string)).toThrowError(
+        "You must pass your PostHog project's api key."
+      )
+    })
+
+    it('should throw if empty api key', () => {
+      expect(() => createTestClient('   ')).toThrowError("You must pass your PostHog project's api key.")
+    })
+
+    it('should throw if non string api key', () => {
+      expect(() => createTestClient({} as string)).toThrowError("You must pass your PostHog project's api key.")
+    })
+
+    it('should initialise default options', () => {
+      expect(posthog as any).toMatchObject({
+        apiKey: 'TEST_API_KEY',
+        host: 'https://us.i.posthog.com',
+        flushAt: 20,
+        flushInterval: 10000,
+      })
+    })
+
+    it('overwrites defaults with options', () => {
+      ;[posthog, mocks] = createTestClient('key', {
+        host: 'https://a.com',
+        flushAt: 1,
+        flushInterval: 2,
+      })
+
+      expect(posthog).toMatchObject({
+        apiKey: 'key',
+        host: 'https://a.com',
+        flushAt: 1,
+        flushInterval: 2,
+      })
+    })
+
+    it('should keep the flushAt option above zero', () => {
+      ;[posthog, mocks] = createTestClient('key', { flushAt: -2 }) as any
+      expect((posthog as any).flushAt).toEqual(1)
+    })
+
+    it('should remove trailing slashes from `host`', () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { host: 'http://my-posthog.com///' })
+
+      expect((posthog as any).host).toEqual('http://my-posthog.com')
+    })
+
+    it('should use bootstrapped distinct ID when present', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { bootstrap: { distinctId: 'new_anon_id' } })
+
+      expect((posthog as any).getDistinctId()).toEqual('new_anon_id')
+      expect((posthog as any).getAnonymousId()).toEqual('new_anon_id')
+
+      await posthog.identify('random_id')
+
+      expect((posthog as any).getDistinctId()).toEqual('random_id')
+      expect((posthog as any).getAnonymousId()).toEqual('new_anon_id')
+    })
+
+    it('should use bootstrapped distinct ID as identified ID when present', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
+        bootstrap: { distinctId: 'new_id', isIdentifiedId: true },
+      })
+      jest.runOnlyPendingTimers()
+
+      expect((posthog as any).getDistinctId()).toEqual('new_id')
+      expect((posthog as any).getAnonymousId()).not.toEqual('new_id')
+
+      await posthog.identify('random_id')
+
+      expect((posthog as any).getDistinctId()).toEqual('random_id')
+      expect((posthog as any).getAnonymousId()).toEqual('new_id')
+    })
+  })
+
+  describe('disabled', () => {
+    it('should not send events when disabled', async () => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
+        disabled: true,
+        flushAt: 1,
+      })
+      jest.runOnlyPendingTimers()
+
+      expect(posthog.getFeatureFlags()).toEqual(undefined)
+      posthog.capture('test')
+      posthog.capture('identify')
+
+      await waitForPromises()
+
+      expect(mocks.fetch).not.toHaveBeenCalled()
+    })
+  })
+})