@pikku/core 0.6.26 → 0.7.0

package/src/scheduler/log-schedulers.ts

@@ -1,20 +0,0 @@
-import { pikkuState } from '../pikku-state.js'
-import { Logger } from '../services/index.js'
-
-/**
- * Logs all the loaded scheduled tasks.
- * @param logger - A logger for logging information.
- */
-export const logSchedulers = (logger: Logger) => {
-  const scheduledTasks = pikkuState('scheduler', 'tasks')
-  if (scheduledTasks.size === 0) {
-    logger.info('No scheduled tasks added')
-    return
-  }
-
-  let scheduledTasksMessage = 'Scheduled tasks:'
-  scheduledTasks.forEach(({ schedule }, name) => {
-    scheduledTasksMessage += `\n\t- ${name} -> ${schedule}`
-  })
-  logger.info(scheduledTasksMessage)
-}

package/src/scheduler/scheduler-runner.ts

@@ -1,87 +0,0 @@
-import type {
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-  CreateSessionServices,
-} from '../types/core.types.js'
-import type { CoreScheduledTask } from './scheduler.types.js'
-import type { CoreAPIFunctionSessionless } from '../types/functions.types.js'
-import { getErrorResponse } from '../errors/error-handler.js'
-import { closeSessionServices } from '../utils.js'
-import { pikkuState } from '../pikku-state.js'
-
-export type RunScheduledTasksParams = {
-  name: string
-  session?: CoreUserSession
-  singletonServices: CoreSingletonServices
-  createSessionServices?: CreateSessionServices<
-    CoreSingletonServices,
-    CoreServices<CoreSingletonServices>,
-    CoreUserSession
-  >
-}
-
-export const addScheduledTask = <
-  APIFunction extends CoreAPIFunctionSessionless<void, void>,
->(
-  scheduledTask: CoreScheduledTask<APIFunction>
-) => {
-  const tasks = pikkuState('scheduler', 'tasks')
-  if (tasks.has(scheduledTask.name)) {
-    throw new Error(`Scheduled task already exists: ${scheduledTask.name}`)
-  }
-  tasks.set(scheduledTask.name, scheduledTask)
-}
-
-class ScheduledTaskNotFoundError extends Error {
-  constructor(title: string) {
-    super(`Scheduled task not found: ${title}`)
-  }
-}
-
-export async function runScheduledTask<
-  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
-  UserSession extends CoreUserSession = CoreUserSession,
->({
-  name,
-  session,
-  singletonServices,
-  createSessionServices,
-}: RunScheduledTasksParams): Promise<void> {
-  let sessionServices: CoreServices | undefined
-  try {
-    const task = pikkuState('scheduler', 'tasks').get(name)
-
-    if (!task) {
-      throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`)
-    }
-
-    singletonServices.logger.info(
-      `Running schedule task: ${name} | schedule: ${task.schedule}`
-    )
-
-    let allServices = singletonServices
-    if (createSessionServices) {
-      const sessionServices = await createSessionServices(
-        singletonServices,
-        {},
-        session
-      )
-      allServices = { ...singletonServices, ...sessionServices }
-    }
-
-    await task.func(allServices, undefined, session!)
-  } catch (e: any) {
-    const errorResponse = getErrorResponse(e)
-
-    if (errorResponse != null) {
-      singletonServices.logger.error(e)
-    }
-
-    throw e
-  } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
-    }
-  }
-}

package/src/scheduler/scheduler.types.ts

@@ -1,29 +0,0 @@
-import { APIDocs, CoreUserSession } from '../types/core.types.js'
-import { CoreAPIFunctionSessionless } from '../types/functions.types.js'
-
-/**
- * Represents metadata for scheduled tasks, including title, schedule, and documentation.
- */
-export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> =
-  Array<{
-    name: string
-    schedule: string
-    session?: UserSession
-    docs?: APIDocs
-    tags?: string[]
-  }>
-
-/**
- * Represents a core scheduled task.
- */
-export type CoreScheduledTask<
-  APIFunction = CoreAPIFunctionSessionless<void, void>,
-  UserSession extends CoreUserSession = CoreUserSession,
-> = {
-  name: string
-  schedule: string
-  func: APIFunction
-  docs?: APIDocs
-  session?: UserSession
-  tags?: string[]
-}

package/src/schema.test.ts

@@ -1,57 +0,0 @@
-import { test, describe, before } from 'node:test'
-import * as assert from 'assert'
-import { addSchema, coerceTopLevelDataFromSchema } from './schema.js'
-
-describe('Schema', () => {
-  describe('coerceQueryStringToArray', () => {
-    before(() => {
-      // Add schemas dynamically using addSchema
-      addSchema('testSchema', {
-        properties: {
-          tags: { type: 'array' },
-          count: { type: 'number' },
-          name: { type: 'string' },
-        },
-      })
-
-      addSchema('booleanSchema', {
-        properties: {
-          isActive: true, // Invalid schema definition, but the function should handle it
-          tags: { type: 'array' },
-        },
-      })
-    })
-
-    test('should split a string into an array for properties of type array', () => {
-      const data = { tags: 'a,b,c' }
-      coerceTopLevelDataFromSchema('testSchema', data)
-      assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
-    })
-
-    test('should not modify properties of type array if they are already arrays', () => {
-      const data = { tags: ['a', 'b', 'c'] }
-      coerceTopLevelDataFromSchema('testSchema', data)
-      assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
-    })
-
-    test('should not modify properties that are not type array', () => {
-      const data = { count: 5, name: 'example' }
-      coerceTopLevelDataFromSchema('testSchema', data)
-      assert.strictEqual(data.count, 5)
-      assert.strictEqual(data.name, 'example')
-    })
-
-    test('should handle cases where the data object does not have a key present in the schema', () => {
-      const data = { unknownKey: 'shouldRemain' }
-      coerceTopLevelDataFromSchema('testSchema', data)
-      assert.strictEqual(data.unknownKey, 'shouldRemain')
-    })
-
-    test('should handle cases where schema properties contain boolean values', () => {
-      const data = { tags: 'a,b,c', isActive: 'true' }
-      coerceTopLevelDataFromSchema('booleanSchema', data)
-      assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
-      assert.strictEqual(data.isActive, 'true') // No coercion should happen
-    })
-  })
-})

package/src/schema.ts

@@ -1,99 +0,0 @@
-import { Logger } from './services/logger.js'
-import { SchemaService } from './services/schema-service.js'
-import { UnprocessableContentError } from './errors/errors.js'
-import { pikkuState } from './pikku-state.js'
-
-/**
- * Adds a schema to the global schemas map.
- * @param name - The name of the schema.
- * @param value - The schema value.
- * @ignore
- */
-export const addSchema = (name: string, value: any) => {
-  pikkuState('misc', 'schemas').set(name, value)
-}
-
-/**
- * Loads a schema and compiles it into a validator.
- * @param logger - A logger for logging information.
- */
-export const compileAllSchemas = (
-  logger: Logger,
-  schemaService?: SchemaService
-) => {
-  if (!schemaService) {
-    throw new Error('SchemaService needs to be defined to load schemas')
-  }
-  const schemas = pikkuState('misc', 'schemas')
-  for (const [name, schema] of schemas) {
-    schemaService.compileSchema(name, schema)
-  }
-  validateAllSchemasLoaded(logger, schemaService)
-}
-
-const validateAllSchemasLoaded = (
-  logger: Logger,
-  schemaService: SchemaService
-) => {
-  const routesMeta = pikkuState('http', 'meta')
-  const validators = schemaService.getSchemaNames()
-
-  const missingSchemas: string[] = []
-
-  for (const route of routesMeta) {
-    if (!route.input || validators.has(route.input)) {
-      continue
-    }
-    missingSchemas.push(route.input)
-  }
-
-  if (missingSchemas.length > 0) {
-    logger.error(
-      `Error: Failed to load schemas:\n.${missingSchemas.join('\n')}`
-    )
-    logger.error('\tHave you run the schema generation?')
-    logger.error('\tnpx @pikku/cli schemas')
-  } else {
-    logger.info('All schemas loaded')
-  }
-}
-
-export const coerceTopLevelDataFromSchema = (schemaName: string, data: any) => {
-  const schema = pikkuState('misc', 'schemas').get(schemaName)
-  for (const key in schema.properties) {
-    const property = schema.properties[key]
-    if (typeof property === 'boolean') {
-      continue
-    }
-    const type = property.type
-    if (typeof type === 'boolean') {
-      continue
-    }
-    if (type === 'array' && typeof data[key] === 'string') {
-      data[key] = data[key].split(',')
-    } else if (type === 'string' && property.format === 'date-time') {
-      data[key] = new Date(data[key])
-    }
-  }
-}
-
-export const validateSchema = async (
-  logger: Logger,
-  schemaService: SchemaService | undefined,
-  schemaName: string | undefined | null,
-  data: any
-) => {
-  if (schemaService) {
-    if (!schemaName) {
-      if (data && (data.length > 0 || Object.keys(data).length > 0)) {
-        logger.warn('No schema provided, but data was passed')
-        throw new UnprocessableContentError('No data expected')
-      } else {
-        return
-      }
-    }
-    const schema = pikkuState('misc', 'schemas').get(schemaName)
-    await schemaService.compileSchema(schemaName, schema)
-    await schemaService.validateSchema(schemaName, data)
-  }
-}

package/src/services/content-service.ts

@@ -1,69 +0,0 @@
-/**
- * Interface for handling content operations.
- */
-export interface ContentService {
-  /**
-   * Signs a content key to provide secure access.
-   * @param contentKey - The key of the content to sign.
-   * @returns A promise that resolves to the signed content key URL.
-   */
-  signContentKey: (
-    contentKey: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ) => Promise<string>
-
-  /**
-   * Signs a URL to provide secure access.
-   * @param url - The URL to sign.
-   * @returns A promise that resolves to the signed URL.
-   */
-  signURL: (
-    url: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ) => Promise<string>
-
-  /**
-   * Gets an upload URL for a file.
-   * @param fileKey - The key of the file to upload.
-   * @param contentType - The content type of the file.
-   * @returns A promise that resolves to an object containing the upload URL and asset key.
-   *  This method generates an upload URL for the specified file key and content type, allowing the file to be uploaded.
-   */
-  getUploadURL: (
-    fileKey: string,
-    contentType: string
-  ) => Promise<{ uploadUrl: string; assetKey: string }>
-
-  /**
-   * Deletes a file.
-   * @param fileName - The name of the file to delete.
-   * @returns A promise that resolves to a boolean indicating success.
-   *  This method deletes the specified file and returns a boolean indicating whether the deletion was successful.
-   */
-  deleteFile?: (fileName: string) => Promise<boolean>
-
-  /**
-   * Writes a file.
-   * @param assetKey - The key of the asset to write.
-   * @param buffer - The buffer containing the file data.
-   * @returns A promise that resolves to a boolean indicating success.
-   */
-  writeFile?: (assetKey: string, buffer: Buffer) => Promise<boolean>
-
-  /**
-   * This method copies the file from the specified absolute path to the location identified by the asset key and returns a boolean indicating success.
-   * @param assetKey - The key of the asset to copy.
-   * @param fromAbsolutePath - The absolute path of the source file.
-   * @returns A promise that resolves to a boolean indicating success.
-   */
-  copyFile?: (assetKey: string, fromAbsolutePath: string) => Promise<boolean>
-
-  /**
-   * Reads a file.
-   * @param assetKey - The key of the asset to read.
-   * @returns A promise that resolves to a buffer containing the file data.
-   */
-  readFile?: (assetKey: string) => Promise<Buffer>
-}

package/src/services/index.ts

@@ -1,17 +0,0 @@
-/**
- * @module @pikku/core
- */
-
-// Interfaces
-export * from './content-service.js'
-export * from './jwt-service.js'
-export * from './logger.js'
-export * from './logger-console.js'
-export * from './secret-service.js'
-export * from './variables-service.js'
-export * from './schema-service.js'
-export * from './user-session-service.js'
-
-// Local implementations
-export * from './local-secrets.js'
-export * from './local-variables.js'

package/src/services/jwt-service.ts

@@ -1,30 +0,0 @@
-import { RelativeTimeInput } from '../time-utils.js'
-
-/**
- * Interface for handling JSON Web Tokens (JWT).
- */
-export interface JWTService {
-  /**
-   * Encodes a payload into a JWT.
-   * @param expiresIn - The expiration time of the token.
-   * @param payload - The payload to encode.
-   * @returns A promise that resolves to the encoded JWT.
-   */
-  encode: <T extends any>(
-    expiresIn: RelativeTimeInput,
-    payload: T
-  ) => Promise<string>
-
-  /**
-   * Decodes a JWT into its payload.
-   * @param hash - The JWT to decode.
-   * @param invalidHashError - An optional error to throw if the hash is invalid.
-   * @param debug - An optional flag for debugging.
-   * @returns A promise that resolves to the decoded payload.
-   */
-  decode: <T>(
-    hash: string,
-    invalidHashError?: Error,
-    debug?: boolean
-  ) => Promise<T>
-}

package/src/services/local-content.ts

@@ -1,91 +0,0 @@
-import { promises } from 'fs'
-import { mkdir } from 'fs/promises'
-import { ContentService, Logger } from '@pikku/core/services'
-
-export interface LocalContentConfig {
-  localFileUploadPath: string
-  uploadUrlPrefix: string
-  assetUrlPrefix: string
-  sizeLimit?: string
-}
-
-export class LocalContent implements ContentService {
-  constructor(
-    private config: LocalContentConfig,
-    private logger: Logger
-  ) {}
-
-  public async init() {}
-
-  public async signURL(url: string): Promise<string> {
-    return `${url}?signed=true`
-  }
-
-  public async signContentKey(assetKey: string): Promise<string> {
-    return `${this.config.assetUrlPrefix}/${assetKey}?signed=true`
-  }
-
-  public async getUploadURL(assetKey: string) {
-    this.logger.debug(`Going to upload with key: ${assetKey}`)
-    return {
-      uploadUrl: `${this.config.uploadUrlPrefix}/${assetKey}`,
-      assetKey,
-    }
-  }
-
-  public async writeFile(assetKey: string, buffer: Buffer): Promise<boolean> {
-    this.logger.debug(`Writing file: ${assetKey}`)
-    try {
-      const path = `${this.config.localFileUploadPath}/${assetKey}`
-      await this.createDirectoryForFile(path)
-      await promises.writeFile(path, buffer)
-    } catch (e) {
-      console.error(e)
-      this.logger.error(`Error inserting content ${assetKey}`, e)
-    }
-    return false
-  }
-
-  public async copyFile(
-    assetKey: string,
-    fromAbsolutePath: string
-  ): Promise<boolean> {
-    this.logger.debug(`Writing file: ${assetKey}`)
-    try {
-      const path = `${this.config.localFileUploadPath}/${assetKey}`
-      await this.createDirectoryForFile(path)
-      await promises.copyFile(fromAbsolutePath, path)
-    } catch (e) {
-      console.error(e)
-      this.logger.error(`Error inserting content ${assetKey}`, e)
-    }
-    return false
-  }
-
-  public async readFile(assetKey: string): Promise<Buffer> {
-    this.logger.debug(`getting key: ${assetKey}`)
-    try {
-      return await promises.readFile(
-        `${this.config.localFileUploadPath}/${assetKey}`
-      )
-    } catch (e) {
-      this.logger.error(`Error get content ${assetKey}`)
-      throw e
-    }
-  }
-
-  public async deleteFile(assetKey: string): Promise<boolean> {
-    this.logger.debug(`deleting key: ${assetKey}`)
-    try {
-      await promises.unlink(`${this.config.localFileUploadPath}/${assetKey}`)
-    } catch (e: any) {
-      this.logger.error(`Error deleting content ${assetKey}`, e)
-    }
-    return false
-  }
-
-  private async createDirectoryForFile(path: string): Promise<void> {
-    const dir = path.split('/').slice(0, -1).join('/')
-    await mkdir(dir, { recursive: true })
-  }
-}

package/src/services/local-secrets.ts

@@ -1,43 +0,0 @@
-import { LocalVariablesService } from './local-variables.js'
-import { SecretService } from './secret-service.js'
-import { VariablesService } from './variables-service.js'
-
-/**
- * Service for retrieving secrets from environment variables.
- */
-export class LocalSecretService implements SecretService {
-  /**
-   * Creates an instance of LocalSecretService.
-   */
-  constructor(
-    private variables: VariablesService = new LocalVariablesService()
-  ) {}
-
-  /**
-   * Retrieves a secret by key.
-   * @param key - The key of the secret to retrieve.
-   * @returns A promise that resolves to the secret value.
-   * @throws {Error} If the secret is not found.
-   */
-  public async getSecretJSON<R>(key: string): Promise<R> {
-    const value = await this.variables.get(key)
-    if (value) {
-      return JSON.parse(value)
-    }
-    throw new Error(`Secret Not Found: ${key}`)
-  }
-
-  /**
-   * Retrieves a secret by key.
-   * @param key - The key of the secret to retrieve.
-   * @returns A promise that resolves to the secret value.
-   * @throws {Error} If the secret is not found.
-   */
-  public async getSecret(key: string): Promise<string> {
-    const value = await this.variables.get(key)
-    if (value) {
-      return value
-    }
-    throw new Error(`Secret Not Found: ${key}`)
-  }
-}

package/src/services/local-variables.ts

@@ -1,17 +0,0 @@
-import { VariablesService } from './variables-service.js'
-
-export class LocalVariablesService implements VariablesService {
-  constructor(
-    private variables: Record<string, string | undefined> = process.env
-  ) {}
-
-  public getAll():
-    | Promise<Record<string, string | undefined>>
-    | Record<string, string | undefined> {
-    return this.variables || {}
-  }
-
-  public get(name: string): Promise<string | undefined> | string | undefined {
-    return this.variables[name]
-  }
-}

package/src/services/logger-console.ts

@@ -1,97 +0,0 @@
-import { Logger, LogLevel } from './logger.js'
-
-/**
- * A logger implementation that logs messages to the console.
- */
-export class ConsoleLogger implements Logger {
-  /**
-   * The current logging level.
-   */
-  private level: LogLevel = LogLevel.info
-
-  /**
-   * Sets the logging level.
-   * @param level - The logging level to set.
-   */
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  /**
-   * Logs a trace message.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
-  trace?(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.trace) {
-      console.trace('TRACE:', message, ...meta)
-    }
-  }
-
-  /**
-   * Logs a debug message.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
-  debug(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.debug) {
-      console.debug('DEBUG:', message, ...meta)
-    }
-  }
-
-  /**
-   * Logs an informational message.
-   * @param messageOrObj - The message or object to log.
-   * @param meta - Additional metadata to log.
-   */
-  info(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.info) {
-      console.info('INFO:', messageOrObj, ...meta)
-    }
-  }
-
-  /**
-   * Logs a warning message.
-   * @param messageOrObj - The message or object to log.
-   * @param meta - Additional metadata to log.
-   */
-  warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.warn) {
-      console.warn('WARN:', messageOrObj, ...meta)
-    }
-  }
-
-  /**
-   * Logs an error message.
-   * @param messageOrObj - The message, object, or error to log.
-   * @param meta - Additional metadata to log.
-   */
-  error(
-    messageOrObj: string | Record<string, any> | Error,
-    ...meta: any[]
-  ): void {
-    if (this.level <= LogLevel.error) {
-      console.error(
-        'ERROR:',
-        messageOrObj instanceof Error ? messageOrObj.message : messageOrObj,
-        ...meta
-      )
-      if (messageOrObj instanceof Error) {
-        console.error('STACK:', messageOrObj.stack)
-      }
-    }
-  }
-
-  /**
-   * Logs a message at a specified level.
-   * @param level - The logging level.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
-  log(level: string, message: string, ...meta: any[]): void {
-    const logLevel = LogLevel[level as keyof typeof LogLevel]
-    if (this.level <= logLevel) {
-      console.log(`${level.toUpperCase()}:`, message, ...meta)
-    }
-  }
-}