@pikku/core 0.12.2 → 0.12.4

package/src/services/variables-service.ts

@@ -1,11 +0,0 @@
-export interface VariablesService {
-  get: (name: string) => Promise<string | undefined> | string | undefined
-  getJSON: <T = unknown>(name: string) => Promise<T | undefined> | T | undefined
-  getAll: () =>
-    | Promise<Record<string, string | undefined>>
-    | Record<string, string | undefined>
-  set: (name: string, value: string) => Promise<void> | void
-  setJSON: (name: string, value: unknown) => Promise<void> | void
-  has: (name: string) => Promise<boolean> | boolean
-  delete: (name: string) => Promise<void> | void
-}

package/src/services/workflow-service.ts

@@ -1,84 +0,0 @@
-import type { SerializedError } from '../types/core.types.js'
-import type {
-  WorkflowRun,
-  WorkflowRunWire,
-  StepState,
-  WorkflowStatus,
-} from '../wirings/workflow/workflow.types.js'
-
-/**
- * Interface for workflow orchestration
- * Handles workflow execution, replay, orchestration logic, and run-level state
- */
-export interface WorkflowService {
-  // Run-level state operations
-  createRun(
-    workflowName: string,
-    input: any,
-    inline: boolean,
-    graphHash: string,
-    wire: WorkflowRunWire
-  ): Promise<string>
-  getRun(id: string): Promise<WorkflowRun | null>
-  getRunHistory(runId: string): Promise<Array<StepState & { stepName: string }>>
-  updateRunStatus(
-    id: string,
-    status: WorkflowStatus,
-    output?: any,
-    error?: SerializedError
-  ): Promise<void>
-  withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>
-  close(): Promise<void>
-
-  // Orchestration operations
-  resumeWorkflow(runId: string): Promise<void>
-  startWorkflow<I>(
-    name: string,
-    input: I,
-    wire: WorkflowRunWire,
-    rpcService: any,
-    options?: { inline?: boolean; startNode?: string }
-  ): Promise<{ runId: string }>
-  runWorkflowJob(runId: string, rpcService: any): Promise<void>
-  orchestrateWorkflow(runId: string, rpcService: any): Promise<void>
-  executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>
-
-  // Step-level state operations
-  insertStepState(
-    runId: string,
-    stepName: string,
-    rpcName: string,
-    data: any,
-    stepOptions?: { retries?: number; retryDelay?: string | number }
-  ): Promise<StepState>
-  getStepState(runId: string, stepName: string): Promise<StepState>
-  setStepRunning(stepId: string): Promise<void>
-  setStepScheduled(stepId: string): Promise<void>
-  setStepResult(stepId: string, result: any): Promise<void>
-  setStepError(stepId: string, error: Error): Promise<void>
-  createRetryAttempt(
-    stepId: string,
-    status: 'pending' | 'running'
-  ): Promise<StepState>
-
-  // Step execution
-  executeWorkflowStep(
-    runId: string,
-    stepName: string,
-    rpcName: string | null,
-    data: any,
-    rpcService: any
-  ): Promise<void>
-
-  // Version operations
-  upsertWorkflowVersion(
-    name: string,
-    graphHash: string,
-    graph: any,
-    source: string
-  ): Promise<void>
-  getWorkflowVersion(
-    name: string,
-    graphHash: string
-  ): Promise<{ graph: any; source: string } | null>
-}

package/src/time-utils.test.ts

@@ -1,56 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { RelativeTimeInput } from './time-utils'
-import {
-  getRelativeTimeOffset,
-  getRelativeTimeOffsetFromNow,
-} from './time-utils'
-
-const approxEqual = (a: number, b: number, delta: number = 10): boolean =>
-  Math.abs(a - b) <= delta
-
-describe('Time Utils', () => {
-  const offsetCases: Array<{ input: RelativeTimeInput; expected: number }> = [
-    { input: { value: 1, unit: 'second' }, expected: 1000 },
-    { input: { value: 2, unit: 'minute' }, expected: 120000 },
-    { input: { value: 1.5, unit: 'hour' }, expected: 5400000 },
-    { input: { value: -1, unit: 'day' }, expected: -86400000 },
-    { input: { value: 1, unit: 'week' }, expected: 604800000 },
-    {
-      input: { value: 2, unit: 'year' },
-      expected: Math.round(2 * 365.25 * 86400 * 1000),
-    },
-  ]
-
-  describe('getRelativeTimeOffset', () => {
-    for (const { input, expected } of offsetCases) {
-      test(`returns ${expected} ms for ${input.value} ${input.unit}`, () => {
-        const actual = getRelativeTimeOffset(input)
-        assert.strictEqual(actual, expected)
-      })
-    }
-  })
-
-  describe('getRelativeTimeOffsetFromNow', () => {
-    test('returns a Date ~1 minute in the future', () => {
-      const now = Date.now()
-      const result = getRelativeTimeOffsetFromNow({ value: 1, unit: 'minute' })
-      const delta = result.getTime() - now
-      assert.ok(
-        approxEqual(delta, 60000),
-        `Expected ~60000ms ahead, got ${delta}ms`
-      )
-    })
-
-    test('returns a Date ~2 hours in the past', () => {
-      const now = Date.now()
-      const result = getRelativeTimeOffsetFromNow({ value: -2, unit: 'hour' })
-      const delta = now - result.getTime()
-      assert.ok(
-        approxEqual(delta, 7200000),
-        `Expected ~7200000ms ago, got ${delta}ms`
-      )
-    })
-  })
-})

package/src/time-utils.ts

@@ -1,107 +0,0 @@
-type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'year'
-
-export interface RelativeTimeInput {
-  value: number // negative = in the past
-  unit: TimeUnit
-}
-
-const multipliers: Record<TimeUnit, number> = {
-  second: 1,
-  minute: 60,
-  hour: 60 * 60,
-  day: 60 * 60 * 24,
-  week: 60 * 60 * 24 * 7,
-  year: Math.round(365.25 * 60 * 60 * 24),
-}
-
-export const getRelativeTimeOffset = ({
-  value,
-  unit,
-}: RelativeTimeInput): number => {
-  return Math.round(value * multipliers[unit]) * 1000 // convert to milliseconds
-}
-
-/**
- * Returns a Unix timestamp (in seconds) offset from now by the given duration.
- * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
- */
-export const getRelativeTimeOffsetFromNow = (
-  relativeTime: RelativeTimeInput
-): Date => {
-  return new Date(Date.now() + getRelativeTimeOffset(relativeTime))
-}
-
-/**
- * Get duration in milliseconds from a string or number
- * @param duration
- * @returns
- */
-export const getDurationInMilliseconds = (
-  duration: string | number
-): number => {
-  if (typeof duration === 'number') {
-    return duration
-  }
-  return parseDurationString(duration)
-}
-
-/**
- * Parse a duration string to milliseconds
- * Supports formats like: '2s', '5s', '5sec', '5seconds', '5m', '5min', '5minutes', '1h', '1hour', '2d', '2day', '1w', '1week'
- *
- * @param duration - Duration string (e.g., '2s', '5min', '2hours', '1day')
- * @returns Duration in milliseconds
- */
-export const parseDurationString = (duration: string): number => {
-  const match = duration.match(
-    /^(\d+)(ms|milliseconds?|s|sec|seconds?|m|min|minutes?|h|hour|hours?|d|day|days?|w|week|weeks?|y|year|years?)$/
-  )
-
-  if (!match) {
-    throw new Error(
-      `Invalid duration format: ${duration}. Use formats like '2s', '5s', '5min', '1hour', '2days', '1week'`
-    )
-  }
-
-  const value = parseInt(match[1], 10)
-  const unitStr = match[2]
-
-  // Handle milliseconds specially
-  if (
-    unitStr === 'ms' ||
-    unitStr === 'millisecond' ||
-    unitStr === 'milliseconds'
-  ) {
-    return value
-  }
-
-  // Map string variations to TimeUnit
-  let unit: TimeUnit
-  if (
-    unitStr === 's' ||
-    unitStr === 'sec' ||
-    unitStr === 'second' ||
-    unitStr === 'seconds'
-  ) {
-    unit = 'second'
-  } else if (
-    unitStr === 'm' ||
-    unitStr === 'min' ||
-    unitStr === 'minute' ||
-    unitStr === 'minutes'
-  ) {
-    unit = 'minute'
-  } else if (unitStr === 'h' || unitStr === 'hour' || unitStr === 'hours') {
-    unit = 'hour'
-  } else if (unitStr === 'd' || unitStr === 'day' || unitStr === 'days') {
-    unit = 'day'
-  } else if (unitStr === 'w' || unitStr === 'week' || unitStr === 'weeks') {
-    unit = 'week'
-  } else if (unitStr === 'y' || unitStr === 'year' || unitStr === 'years') {
-    unit = 'year'
-  } else {
-    throw new Error(`Unknown time unit: ${unitStr}`)
-  }
-
-  return getRelativeTimeOffset({ value, unit })
-}