@pikku/core 0.11.2 → 0.12.1

package/src/wirings/scheduler/scheduler-runner.test.ts

@@ -6,8 +6,8 @@ import {
   getScheduledTasks,
 } from './scheduler-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import { CoreScheduledTask } from './scheduler.types.js'
-import { CoreUserSession } from '../../types/core.types.js'
+import type { CoreScheduledTask } from './scheduler.types.js'
+import type { CoreUserSession } from '../../types/core.types.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -38,7 +38,7 @@ describe('wireScheduler', () => {
 
     // Set up metadata first
     pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }
@@ -63,7 +63,10 @@ describe('wireScheduler', () => {
     assert.throws(
       () => wireScheduler(mockTask),
       (error: any) => {
-        assert.equal(error.message, 'Task metadata not found')
+        assert.equal(
+          error.message,
+          "Missing generated metadata for scheduled task 'missing-meta-task'"
+        )
         return true
       }
     )
@@ -81,7 +84,7 @@ describe('wireScheduler', () => {
 
     // Set up metadata
     pikkuState(null, 'scheduler', 'meta')['duplicate-task'] = {
-      pikkuFuncName: 'scheduler_duplicate-task',
+      pikkuFuncId: 'scheduler_duplicate-task',
       name: 'duplicate-task',
       schedule: '0 0 * * *',
     }
@@ -121,7 +124,7 @@ describe('wireScheduler', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['task-with-middleware'] = {
-      pikkuFuncName: 'scheduler_task-with-middleware',
+      pikkuFuncId: 'scheduler_task-with-middleware',
       name: 'task-with-middleware',
       schedule: '0 0 * * *',
     }
@@ -152,21 +155,23 @@ describe('runScheduledTask', () => {
 
     // Set up metadata and task
     pikkuState(null, 'scheduler', 'meta')['simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+      pikkuFuncId: 'scheduler_simple-task',
       name: 'simple-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+      pikkuFuncId: 'scheduler_simple-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     await runScheduledTask({
       name: 'simple-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.equal(taskExecuted, true)
@@ -185,31 +190,33 @@ describe('runScheduledTask', () => {
       schedule: '0 0 * * *',
       func: {
         func: async (services: any, data: any, wire: any) => {
-          receivedSession = await wire.session.get()
+          receivedSession = await wire.getSession()
         },
         auth: false,
       },
     }
 
     pikkuState(null, 'scheduler', 'meta')['task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+      pikkuFuncId: 'scheduler_task-with-session',
       name: 'task-with-session',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+      pikkuFuncId: 'scheduler_task-with-session',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const session: CoreUserSession = { userId: 'user123' }
 
     await runScheduledTask({
       name: 'task-with-session',
       session,
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.deepEqual(receivedSession, session)
@@ -217,12 +224,14 @@ describe('runScheduledTask', () => {
 
   test('should throw ScheduledTaskNotFoundError when task not found', async () => {
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'non-existent-task',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -246,12 +255,14 @@ describe('runScheduledTask', () => {
     pikkuState(null, 'scheduler', 'tasks').set('task-without-meta', mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'task-without-meta',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -274,24 +285,26 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+      pikkuFuncId: 'scheduler_skipped-task',
       name: 'skipped-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+      pikkuFuncId: 'scheduler_skipped-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'skipped-task',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -317,24 +330,26 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       name: 'skipped-task-no-reason',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'skipped-task-no-reason',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -363,22 +378,24 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+      pikkuFuncId: 'scheduler_wire-task',
       name: 'wire-task',
       schedule: '*/5 * * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+      pikkuFuncId: 'scheduler_wire-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await runScheduledTask({
       name: 'wire-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.equal(capturedWire.scheduledTask.name, 'wire-task')
@@ -401,26 +418,30 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+      pikkuFuncId: 'scheduler_session-services-task',
       name: 'session-services-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+      pikkuFuncId: 'scheduler_session-services-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
-
-    await runScheduledTask({
-      name: 'session-services-task',
-      singletonServices: { logger: mockLogger } as any,
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
       createWireServices: async () => {
         createWireServicesCalled = true
         return mockWireService as any
       },
+    } as any)
+
+    await runScheduledTask({
+      name: 'session-services-task',
     })
 
     assert.equal(createWireServicesCalled, true)
@@ -446,23 +467,27 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+      pikkuFuncId: 'scheduler_cleanup-task',
       name: 'cleanup-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+      pikkuFuncId: 'scheduler_cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: async () => mockWireService as any,
+    } as any)
 
     await runScheduledTask({
       name: 'cleanup-task',
-      singletonServices: { logger: mockLogger } as any,
-      createWireServices: async () => mockWireService as any,
     })
 
     assert.equal(closeCalled, true)
@@ -490,24 +515,28 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       name: 'error-cleanup-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: async () => mockWireService as any,
+    } as any)
 
     await assert.rejects(async () => {
       await runScheduledTask({
         name: 'error-cleanup-task',
-        singletonServices: { logger: mockLogger } as any,
-        createWireServices: async () => mockWireService as any,
       })
     })
 
@@ -527,23 +556,25 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+      pikkuFuncId: 'scheduler_error-task',
       name: 'error-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+      pikkuFuncId: 'scheduler_error-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(async () => {
       await runScheduledTask({
         name: 'error-task',
-        singletonServices: { logger: mockLogger } as any,
       })
     })
 
@@ -574,22 +605,24 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+      pikkuFuncId: 'scheduler_middleware-task',
       name: 'middleware-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+      pikkuFuncId: 'scheduler_middleware-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await runScheduledTask({
       name: 'middleware-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.deepEqual(executionOrder, ['middleware', 'task'])
@@ -608,7 +641,7 @@ describe('getScheduledTasks', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }

package/src/wirings/scheduler/scheduler-runner.ts

@@ -1,17 +1,18 @@
-import {
-  PikkuWire,
-  type CoreServices,
-  type CoreSingletonServices,
-  type CoreUserSession,
-  type CreateWireServices,
-} from '../../types/core.types.js'
+import type { PikkuWire, CoreUserSession } from '../../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
-import { closeWireServices } from '../../utils.js'
-import { pikkuState } from '../../pikku-state.js'
+import { PikkuMissingMetaError } from '../../errors/errors.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { PikkuSessionService } from '../../services/user-session-service.js'
 import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+} from '../../services/user-session-service.js'
+import type {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
@@ -19,12 +20,6 @@ import {
 export type RunScheduledTasksParams = {
   name: string
   session?: CoreUserSession
-  singletonServices: CoreSingletonServices
-  createWireServices?: CreateWireServices<
-    CoreSingletonServices,
-    CoreServices<CoreSingletonServices>,
-    CoreUserSession
-  >
 }
 
 export const wireScheduler = <
@@ -37,9 +32,11 @@ export const wireScheduler = <
   const meta = pikkuState(null, 'scheduler', 'meta')
   const taskMeta = meta[scheduledTask.name]
   if (!taskMeta) {
-    throw new Error('Task metadata not found')
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for scheduled task '${scheduledTask.name}'`
+    )
   }
-  addFunction(taskMeta.pikkuFuncName, {
+  addFunction(taskMeta.pikkuFuncId, {
     func: scheduledTask.func.func,
     auth: scheduledTask.func.auth,
     permissions: scheduledTask.func.permissions,
@@ -72,10 +69,9 @@ class ScheduledTaskSkippedError extends PikkuError {
 export async function runScheduledTask({
   name,
   session,
-  singletonServices,
-  createWireServices,
 }: RunScheduledTasksParams): Promise<void> {
-  let wireServices: any
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   const task = pikkuState(null, 'scheduler', 'tasks').get(name)
   const meta = pikkuState(null, 'scheduler', 'meta')[name]
 
@@ -103,7 +99,7 @@ export async function runScheduledTask({
         throw new ScheduledTaskSkippedError(name, reason)
       },
     },
-    session: userSession,
+    ...createMiddlewareSessionWireProps(userSession),
   }
 
   try {
@@ -111,7 +107,7 @@ export async function runScheduledTask({
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
       singletonServices,
       createWireServices,
       auth: false,
@@ -120,6 +116,7 @@ export async function runScheduledTask({
       wireMiddleware: task.middleware,
       tags: task.tags,
       wire,
+      sessionService: userSession,
     })
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
@@ -127,10 +124,6 @@ export async function runScheduledTask({
       singletonServices.logger.error(e)
     }
     throw e
-  } finally {
-    if (wireServices) {
-      await closeWireServices(singletonServices.logger, wireServices)
-    }
   }
 }
 

package/src/wirings/scheduler/scheduler.types.ts

@@ -1,9 +1,9 @@
-import {
+import type {
   CoreUserSession,
   CorePikkuMiddleware,
   CommonWireMeta,
 } from '../../types/core.types.js'
-import {
+import type {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'

package/src/wirings/secret/index.ts

@@ -0,0 +1,9 @@
+export { wireSecret } from './secret.types.js'
+export type {
+  CoreSecret,
+  OAuth2CredentialConfig,
+  SecretDefinitionMeta,
+  SecretDefinitionsMeta,
+  SecretDefinitions,
+} from './secret.types.js'
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'

package/src/wirings/secret/secret.types.ts

@@ -0,0 +1,32 @@
+export type CoreSecret<T = unknown> = {
+  name: string
+  displayName: string
+  description?: string
+  secretId: string
+  schema: T
+}
+
+export type OAuth2CredentialConfig = {
+  tokenSecretId: string
+  authorizationUrl: string
+  tokenUrl: string
+  scopes: string[]
+  pkce?: boolean
+  additionalParams?: Record<string, string>
+}
+
+export type SecretDefinitionMeta = {
+  name: string
+  displayName: string
+  description?: string
+  secretId: string
+  schema?: Record<string, unknown> | string
+  oauth2?: OAuth2CredentialConfig
+  sourceFile?: string
+}
+
+export type SecretDefinitionsMeta = Record<string, SecretDefinitionMeta>
+
+export type SecretDefinitions = SecretDefinitionMeta[]
+
+export const wireSecret = <T>(_config: CoreSecret<T>): void => {}

package/src/wirings/secret/validate-secret-definitions.test.ts

@@ -0,0 +1,140 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'
+
+describe('validateAndBuildSecretDefinitionsMeta', () => {
+  test('should build meta from single definition', () => {
+    const definitions = [
+      {
+        name: 'stripe',
+        displayName: 'Stripe',
+        description: 'API key',
+        secretId: 'STRIPE_KEY',
+        sourceFile: 'a.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['stripe'])
+    assert.strictEqual(result['stripe'].secretId, 'STRIPE_KEY')
+    assert.strictEqual(result['stripe'].displayName, 'Stripe')
+  })
+
+  test('should allow duplicate secretId with same schema', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      schemaLookup
+    )
+    assert.ok(result['cred1'])
+    assert.ok(result['cred2'])
+  })
+
+  test('should throw when duplicate secretId has different schemas', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
+      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, schemaLookup),
+      (err: any) => err.message.includes('different schemas')
+    )
+  })
+
+  test('should throw when duplicate secretId has different oauth2 configs', () => {
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'C1',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'google' },
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'C2',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'github' },
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, new Map()),
+      (err: any) => err.message.includes('different configurations')
+    )
+  })
+
+  test('should handle empty definitions', () => {
+    const result = validateAndBuildSecretDefinitionsMeta([], new Map())
+    assert.deepStrictEqual(result, {})
+  })
+
+  test('should not duplicate names in meta', () => {
+    const definitions = [
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['same'])
+    assert.strictEqual(result['same'].secretId, 'KEY1')
+  })
+})