@open-mercato/shared 0.8.1-develop.7274.1.21a0083828 → 0.8.1-develop.7294.1.0ef99fc518

package/src/lib/schedule/__tests__/interval.test.ts

@@ -0,0 +1,37 @@
+import {
+  MIN_SCHEDULE_INTERVAL_MS,
+  isValidScheduleInterval,
+  parseScheduleInterval,
+} from '../interval'
+
+describe('parseScheduleInterval', () => {
+  it('converts each documented unit to milliseconds', () => {
+    expect(parseScheduleInterval('90s')).toBe(90 * 1000)
+    expect(parseScheduleInterval('15m')).toBe(15 * 60 * 1000)
+    expect(parseScheduleInterval('6h')).toBe(6 * 60 * 60 * 1000)
+    expect(parseScheduleInterval('1d')).toBe(24 * 60 * 60 * 1000)
+  })
+
+  it('rejects a value that carries no unit', () => {
+    expect(() => parseScheduleInterval('3600')).toThrow('Invalid interval format: 3600')
+  })
+})
+
+describe('isValidScheduleInterval', () => {
+  it.each(['1h', '6h', '24h', '15m', '60s', '1d'])('accepts the documented format %s', (interval) => {
+    expect(isValidScheduleInterval(interval)).toBe(true)
+  })
+
+  it.each(['3600', '', ' 1h', '1h ', '1.5h', '-1h', 'hourly', '1w', '1H'])(
+    'rejects %p, which the scheduler could never run',
+    (interval) => {
+      expect(isValidScheduleInterval(interval)).toBe(false)
+    },
+  )
+
+  it('rejects an interval shorter than the enforced minimum', () => {
+    expect(MIN_SCHEDULE_INTERVAL_MS).toBe(60 * 1000)
+    expect(isValidScheduleInterval('30s')).toBe(false)
+    expect(isValidScheduleInterval('0m')).toBe(false)
+  })
+})

package/src/lib/schedule/interval.ts

@@ -0,0 +1,45 @@
+/**
+ * Canonical interval-format rules for recurring schedules.
+ *
+ * Both the scheduler runtime and the API validators that reject a schedule
+ * before it is persisted read the format from here, so the documented format
+ * (`<number><unit>`, e.g. `15m`, `1h`, `24h`) cannot drift between the layer
+ * that accepts a value and the layer that has to run it.
+ */
+export const MIN_SCHEDULE_INTERVAL_MS = 60 * 1000
+
+export const SCHEDULE_INTERVAL_PATTERN = /^(\d+)(s|m|h|d)$/
+
+const UNIT_MULTIPLIERS: Record<string, number> = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000,
+}
+
+export type ScheduleIntervalUnit = 's' | 'm' | 'h' | 'd'
+
+export type ScheduleIntervalParts = {
+  amount: number
+  unit: ScheduleIntervalUnit
+}
+
+export function matchScheduleInterval(interval: string): ScheduleIntervalParts | null {
+  const match = SCHEDULE_INTERVAL_PATTERN.exec(interval)
+  if (!match) return null
+  return { amount: Number.parseInt(match[1], 10), unit: match[2] as ScheduleIntervalUnit }
+}
+
+export function parseScheduleInterval(interval: string): number {
+  const parts = matchScheduleInterval(interval)
+  if (!parts) {
+    throw new Error(`Invalid interval format: ${interval}. Expected format: <number><unit> (e.g., 15m, 2h, 1d)`)
+  }
+  return parts.amount * UNIT_MULTIPLIERS[parts.unit]
+}
+
+export function isValidScheduleInterval(interval: string): boolean {
+  const parts = matchScheduleInterval(interval)
+  if (!parts) return false
+  return parts.amount * UNIT_MULTIPLIERS[parts.unit] >= MIN_SCHEDULE_INTERVAL_MS
+}

package/src/lib/schedule/invalidScheduleValue.ts

@@ -0,0 +1,33 @@
+export const INVALID_SCHEDULE_VALUE_CODE = 'INVALID_SCHEDULE_VALUE'
+
+export type ScheduleValueKind = 'cron' | 'interval'
+
+export type InvalidScheduleValueError = Error & {
+  code: typeof INVALID_SCHEDULE_VALUE_CODE
+  scheduleType: ScheduleValueKind
+  scheduleValue: string
+}
+
+export function createInvalidScheduleValueError(
+  scheduleType: ScheduleValueKind,
+  scheduleValue: string,
+  message: string,
+): InvalidScheduleValueError {
+  return Object.assign(new Error(message), {
+    code: INVALID_SCHEDULE_VALUE_CODE,
+    scheduleType,
+    scheduleValue,
+  } as const)
+}
+
+/**
+ * Structural check rather than `instanceof`: the error crosses a package
+ * boundary (and a production bundle), where a duplicated class identity would
+ * make `instanceof` silently false.
+ */
+export function isInvalidScheduleValueError(error: unknown): error is InvalidScheduleValueError {
+  if (typeof error !== 'object' || error === null) return false
+  const candidate = error as { code?: unknown; scheduleType?: unknown }
+  return candidate.code === INVALID_SCHEDULE_VALUE_CODE
+    && (candidate.scheduleType === 'cron' || candidate.scheduleType === 'interval')
+}