Add optional weekend into market status

Author: mxiao-cll

package.json

@@ -15,7 +15,8 @@
     "pino-pretty": "13.1.2",
     "prom-client": "15.1.3",
     "redlock": "5.0.0-beta.2",
-    "ws": "8.18.3"
+    "ws": "8.18.3",
+    "@date-fns/tz": "1.4.1"
   },
   "scripts": {
     "build": "rm -rf dist/src && mkdir -p ./dist/src && cp package.json dist/src && cp README.md dist/src && tsc && yarn pre-build-generator",

src/adapter/market-status.ts

@@ -1,6 +1,8 @@
 import { TransportGenerics } from '../transports'
+import { AdapterInputError } from '../validation/error'
 import { AdapterEndpoint } from './endpoint'
-
+import { AdapterEndpointParams } from './types'
+import { TZDate } from '@date-fns/tz'
 /**
  * Base input parameter config that any [[MarketStatusEndpoint]] must extend
  */
@@ -17,6 +19,11 @@ export const marketStatusEndpointInputParametersDefinition = {
     options: ['regular', '24/5'],
     default: 'regular',
   },
+  weekend: {
+    type: 'string',
+    description:
+      'DHH-DHH:TZ, 520-020:America/New_York means Fri 20:00 to Sun 20:00 Eastern Time Zone',
+  },
 } as const
 
 export enum MarketStatus {
@@ -58,4 +65,77 @@ export type MarketStatusEndpointGenerics = TransportGenerics & {
  */
 export class MarketStatusEndpoint<
   T extends MarketStatusEndpointGenerics,
-> extends AdapterEndpoint<T> {}
+> extends AdapterEndpoint<T> {
+  constructor(params: AdapterEndpointParams<T>) {
+    params.customInputValidation = (req, _adapterSettings) => {
+      const data = req.requestContext.data as Record<string, string>
+      if (data['type'] === '24/5') {
+        validateWeekend(data['weekend'])
+      }
+      return undefined
+    }
+    super(params)
+  }
+}
+
+export const validateWeekend = (weekend?: string) => {
+  const dayHour = /[0-6](0\d|1\d|2[0-3])/
+  const timezonePattern = /[^\s]+/
+  const regex = new RegExp(`^(${dayHour.source})-(${dayHour.source}):(${timezonePattern.source})$`)
+
+  const match = weekend?.match(regex)
+  if (!match) {
+    throw new AdapterInputError({
+      statusCode: 400,
+      message: '[Param: weekend] does not match format of DHH-DHH:TZ',
+    })
+  }
+
+  try {
+    // eslint-disable-next-line new-cap
+    Intl.DateTimeFormat(undefined, { timeZone: weekend?.split(':')[1] })
+  } catch (error) {
+    throw new AdapterInputError({
+      statusCode: 400,
+      message: `[Param: weekend] is not valid: ${error}`,
+    })
+  }
+}
+
+export const isWeekend = (weekend?: string) => {
+  validateWeekend(weekend)
+
+  // Weekend looks like 520-020:America/New_York
+  const [range, tz] = (weekend || '').split(':')
+  const [start, end] = range.split('-')
+
+  const startDay = Number(start[0])
+  const startHour = Number(start.slice(1))
+  const endDay = Number(end[0])
+  const endHour = Number(end.slice(1))
+
+  const nowDay = TZDate.tz(tz).getDay()
+  const nowHour = TZDate.tz(tz).getHours()
+
+  // Case 1: weekend does NOT wrap around the week
+  if (startDay < endDay || (startDay === endDay && startHour < endHour)) {
+    if (nowDay < startDay || nowDay > endDay) {
+      return false
+    } else if (nowDay === startDay && nowHour < startHour) {
+      return false
+    } else if (nowDay === endDay && nowHour >= endHour) {
+      return false
+    }
+    return true
+  }
+
+  // Case 2: weekend wraps around (e.g. Fri → Sun)
+  if (nowDay > startDay || nowDay < endDay) {
+    return true
+  } else if (nowDay === startDay && nowHour >= startHour) {
+    return true
+  } else if (nowDay === endDay && nowHour < endHour) {
+    return true
+  }
+  return false
+}

test/adapter/market-status.test.ts

@@ -0,0 +1,228 @@
+import test from 'ava'
+import '../../src/adapter'
+import {
+  validateWeekend,
+  isWeekend,
+  MarketStatusEndpoint,
+  marketStatusEndpointInputParametersDefinition,
+  MarketStatusEndpointGenerics,
+} from '../../src/adapter/market-status'
+import { InputParameters } from '../../src/validation'
+import { TestAdapter } from '../../src/util/testing-utils'
+import { Adapter } from '../../src/adapter/basic'
+import FakeTimers from '@sinonjs/fake-timers'
+import { Transport } from '../../src/transports'
+import { ResponseCache } from '../../src/cache/response'
+
+test('MarketStatusEndpoint - validates weekend when type is 24/5', async (t) => {
+  class MarketStatusTestTransport implements Transport<MarketStatusEndpointGenerics> {
+    name!: string
+    responseCache!: ResponseCache<MarketStatusEndpointGenerics>
+
+    async initialize() {}
+
+    async foregroundExecute() {
+      return {
+        data: {
+          result: 2,
+          statusString: 'OPEN',
+        },
+        result: 2,
+        statusCode: 200,
+        timestamps: {
+          providerDataRequestedUnixMs: 0,
+          providerDataReceivedUnixMs: 0,
+          providerIndicatedTimeUnixMs: 0,
+        },
+      }
+    }
+  }
+
+  const adapter = new Adapter({
+    name: 'TEST',
+    endpoints: [
+      new MarketStatusEndpoint({
+        name: 'test',
+        inputParameters: new InputParameters(marketStatusEndpointInputParametersDefinition),
+        transport: new MarketStatusTestTransport(),
+      }),
+    ],
+  })
+
+  const testAdapter = await TestAdapter.start(
+    adapter,
+    {} as {
+      testAdapter: TestAdapter
+    },
+  )
+
+  const response1 = await testAdapter.request({
+    market: 'BTC',
+    type: 'regular',
+    weekend: '520-020',
+    endpoint: 'test',
+  })
+  t.is(response1.statusCode, 200, 'Should succeed with invalid weekend when type is regular')
+
+  const response2 = await testAdapter.request({
+    market: 'BTC',
+    type: '24/5',
+    weekend: '520-020',
+    endpoint: 'test',
+  })
+  t.is(response2.statusCode, 400, 'Should fail with invalid weekend format')
+  t.true(
+    response2.json().error.message.includes('[Param: weekend] does not match format'),
+    'Error message should mention weekend format',
+  )
+
+  const response3 = await testAdapter.request({
+    market: 'BTC',
+    type: '24/5',
+    weekend: '520-020:America/New_York',
+    endpoint: 'test',
+  })
+  t.is(response3.statusCode, 200, 'Should succeed with valid weekend')
+
+  await testAdapter.api.close()
+})
+
+test('validateWeekend - success', (t) => {
+  t.notThrows(() => {
+    validateWeekend('520-020:America/New_York')
+    validateWeekend('000-123:UTC')
+    validateWeekend('123-423:Europe/London')
+    validateWeekend('600-023:Asia/Tokyo')
+  })
+})
+
+test('validateWeekend - bad format', (t) => {
+  t.throws(() => {
+    validateWeekend('520020:America/New_York')
+  })
+  t.throws(() => {
+    validateWeekend('520-020America/New_York')
+  })
+  t.throws(() => {
+    validateWeekend('520-020:')
+  })
+  t.throws(() => {
+    validateWeekend('55-020:UTC')
+  })
+  t.throws(() => {
+    validateWeekend('55-20:UTC')
+  })
+  t.throws(() => {
+    validateWeekend('')
+  })
+  t.throws(() => {
+    validateWeekend()
+  })
+  t.throws(() => {
+    validateWeekend('520:020-America/New_York')
+  })
+  t.throws(() => {
+    validateWeekend('520-020: ')
+  })
+})
+
+test('validateWeekend - bad number', (t) => {
+  t.throws(() => {
+    validateWeekend('720-020:UTC')
+  })
+  t.throws(() => {
+    validateWeekend('524-020:UTC')
+  })
+  t.throws(() => {
+    validateWeekend('525-020:UTC')
+  })
+})
+
+test('validateWeekend - invalid timezone', (t) => {
+  t.throws(() => {
+    validateWeekend('520-020:Invalid/Timezone')
+    validateWeekend('520-020:AmericaNew_York')
+  })
+})
+
+const clock = FakeTimers.install({ toFake: ['Date'] })
+
+test.after(() => {
+  clock.uninstall()
+})
+
+test('isWeekend - UTC', (t) => {
+  // Saturday 12:00 -> 612
+  clock.setSystemTime(new Date('2024-01-06T12:00:00Z').getTime())
+
+  t.false(isWeekend('000-123:UTC'), 'Before start day')
+  t.false(isWeekend('400-500:UTC'), 'After end day')
+  t.false(isWeekend('613-620:UTC'), 'Before start hour')
+  t.false(isWeekend('610-612:UTC'), 'After end hour')
+
+  t.true(isWeekend('610-620:UTC'), 'Non-wrapping: middle of weekend should return true')
+  t.true(isWeekend('600-023:UTC'), 'Non-wrapping: spanning multiple days should return true')
+  t.true(isWeekend('612-615:UTC'), 'Non-wrapping: same day, at start hour should return true')
+
+  t.true(isWeekend('520-020:UTC'), 'Wrapping: nowDay > startDay should return true')
+  t.true(isWeekend('400-200:UTC'), 'Wrapping: nowDay > startDay should return true')
+
+  t.true(isWeekend('612-020:UTC'), 'After start hour')
+  t.true(isWeekend('520-613:UTC'), 'Before end hour')
+
+  t.false(isWeekend('620-610:UTC'), 'Wrapping same day: between end and start should return false')
+})
+
+test('isWeekend - ET', (t) => {
+  // Saturday 12:00 UTC = Saturday 07:00 EST -> 607
+  clock.setSystemTime(new Date('2024-01-06T12:00:00Z').getTime())
+
+  t.false(isWeekend('000-123:America/New_York'), 'Before start day')
+  t.false(isWeekend('400-500:America/New_York'), 'After end day')
+  t.false(isWeekend('608-620:America/New_York'), 'Before start hour')
+  t.false(isWeekend('605-607:America/New_York'), 'After end hour')
+
+  t.true(isWeekend('605-620:America/New_York'), 'Non-wrapping: middle of weekend')
+  t.true(isWeekend('600-023:America/New_York'), 'Non-wrapping: spanning multiple days')
+  t.true(isWeekend('607-610:America/New_York'), 'Non-wrapping: same day, at start hour ')
+
+  t.true(isWeekend('520-020:America/New_York'), 'Wrapping: nowDay > startDay should return true')
+  t.true(isWeekend('400-200:America/New_York'), 'Wrapping: nowDay > startDay should return true')
+
+  t.true(isWeekend('607-020:America/New_York'), 'After start hour')
+  t.true(isWeekend('520-608:America/New_York'), 'Before end hour')
+
+  t.false(isWeekend('620-607:America/New_York'), 'Wrapping same day: at end hour should')
+})
+
+test('isWeekend - ET - Fri to Sun 8 to 8', (t) => {
+  // Weekend: Fri 20:00 to Sun 20:00 ET (520-020:America/New_York)
+  const range = '520-020:America/New_York'
+  // Thu 21:00 ET
+  clock.setSystemTime(new Date('2024-01-05T02:00:00Z').getTime())
+  t.false(isWeekend(range), 'Before start day')
+  // Fri 19:00 ET
+  clock.setSystemTime(new Date('2024-01-06T00:00:00Z').getTime())
+  t.false(isWeekend(range), 'On start day, before start hour')
+  // Fri 20:00 ET
+  clock.setSystemTime(new Date('2024-01-06T01:00:00Z').getTime())
+  t.true(isWeekend(range), 'On start day, at start hour')
+  // Fri 23:00 ET
+  clock.setSystemTime(new Date('2024-01-06T04:00:00Z').getTime())
+  t.true(isWeekend(range), 'On start day, after start hour')
+  // Sat 12:00 ET
+  clock.setSystemTime(new Date('2024-01-06T17:00:00Z').getTime())
+  t.true(isWeekend(range), 'Middle day (Saturday)')
+  // Sun 19:00 ET
+  clock.setSystemTime(new Date('2024-01-08T00:00:00Z').getTime())
+  t.true(isWeekend(range), 'On end day, before end hour')
+  // Sun 20:00 ET
+  clock.setSystemTime(new Date('2024-01-08T01:00:00Z').getTime())
+  t.false(isWeekend(range), 'On end day, at end hour')
+  // Sun 21:00 ET
+  clock.setSystemTime(new Date('2024-01-08T02:00:00Z').getTime())
+  t.false(isWeekend(range), 'On end day, after end hour')
+  // Mon 10:00 ET
+  clock.setSystemTime(new Date('2024-01-08T15:00:00Z').getTime())
+  t.false(isWeekend(range), 'After end day')
+})

yarn.lock

@@ -14,6 +14,11 @@
   dependencies:
     "@jridgewell/trace-mapping" "0.3.9"
 
+"@date-fns/tz@1.4.1":
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/@date-fns/tz/-/tz-1.4.1.tgz#2d905f282304630e07bef6d02d2e7dbf3f0cc4e4"
+  integrity sha512-P5LUNhtbj6YfI3iJjw5EL9eUAG6OitD0W3fWQcpQjDRc/QIsL0tRNuO1PcDvPccWL1fSTXXdE1ds+l95DV/OFA==
+
 "@eslint-community/eslint-utils@^4.7.0":
   version "4.7.0"
   resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz#607084630c6c033992a082de6e6fbc1a8b52175a"