cordo 2.4.2 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordo",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "A framework for handling complex discord api interactions",
   "exports": {
     ".": "./src/index.ts",

package/src/core/gateway.ts

@@ -3,6 +3,7 @@ import type { Method } from "axios"
 import axios from "axios"
 import { FunctCompiler } from "../functions/compiler"
 import { FunctInternals } from "../functions/funct"
+import { MissingContextError } from "../errors/builtin/missing-context"
 import { InteractionInternals, type CordoInteraction } from "./interaction"
 import { CordoMagic } from "./magic"
 import type { LockfileInternals } from "./files/lockfile"
@@ -46,6 +47,8 @@ export namespace CordoGateway {
 
   function apiRequest(method: Method, url: string, body?: Record<string, any>) {
     const config = CordoMagic.getConfig()
+    if (!config)
+      throw new MissingContextError('Could not make API request, no config found in context.')
     return axios({
       method,
       url,
@@ -88,6 +91,8 @@ export namespace CordoGateway {
       return null
 
     const config = CordoMagic.getConfig()
+    if (!config)
+      throw new MissingContextError('Could not respond to interaction, no config found in context.')
     if (!config.client.id) {
       console.warn(`No client id provided in config. Cannot respond to interactions.`)
       return null
@@ -108,7 +113,10 @@ export namespace CordoGateway {
     i = await Hooks.callHook('onBeforeHandle', i)
     if (!i) return
 
-    const deferAfter = CordoMagic.getConfig().upstream.autoDeferMs
+    const config = CordoMagic.getConfig()
+    if (!config)
+      throw new MissingContextError('Could not handle interaction, no config found in context.')
+    const deferAfter = config.upstream.autoDeferMs
     if (deferAfter) {
       setTimeout(() => {
         if (!InteractionInternals.get(i).answered)

package/src/core/hooks.ts

@@ -12,10 +12,17 @@ export namespace Hooks {
     hookName: Name,
     value: Value,
     context?: Context,
-    config?: CordoConfig
+    config?: NonNullable<CordoConfig>
   ): ReturnType<NonNullable<CordoConfig['hooks'][Name]>> {
-    if (!config) 
-      config = CordoMagic.getConfig()
+    if (!config) {
+      const contextConfig = CordoMagic.getConfig()
+      if (!contextConfig) {
+        console.warn(`Calling hook '${hookName}' failed, no config provided and no config found in context.`)
+        return value as any
+      }
+
+      config = contextConfig
+    }
 
     const hook = config.hooks[hookName]
     if (!hook)
@@ -35,7 +42,7 @@ export namespace Hooks {
   }
 
   export function isDefined(name: keyof CordoConfig['hooks']) {
-    return !!CordoMagic.getConfig().hooks[name]
+    return !!CordoMagic.getConfig()?.hooks[name]
   }
 
 }

package/src/core/index.ts

@@ -5,6 +5,8 @@ import { ConfigInternals, type CordoConfig, type ParsedCordoConfig } from './fil
 import { LockfileInternals } from './files/lockfile'
 import { CordoGateway } from './gateway'
 import { RoutingFilesystem } from './routing/filesystem'
+import { CordoMagic } from './magic'
+import type { CordoInteraction } from './interaction'
 
 export { type DynamicTypes } from './dynamic-types'
 export { type CordoConfig, defineCordoConfig } from './files/config'
@@ -76,3 +78,25 @@ export const Cordo = {
   respondToRawInteraction: CordoGateway.respondTo,
 }
 Object.freeze(Cordo)
+
+
+export namespace Extend {
+
+  export function runInCordoContext(
+    fn: () => any,
+    ctx?: {
+      invoker?: CordoInteraction
+      lockfile?: LockfileInternals.ParsedLockfile
+      config?: ParsedCordoConfig
+    }
+  ) {
+    CordoMagic.Internals.runWithCtx(fn, {
+      invoker: ctx?.invoker ?? null,
+      lockfile: ctx?.lockfile ?? null,
+      config: ctx?.config ?? null,
+      cwd: '',
+      idCounter: 0
+    })
+  }
+
+}

package/src/core/magic.ts

@@ -7,9 +7,9 @@ import type { ParsedCordoConfig } from './files/config'
 
 type Context = {
   cwd: string
-  lockfile: LockfileInternals.ParsedLockfile
-  config: ParsedCordoConfig
-  invoker: CordoInteraction
+  lockfile: LockfileInternals.ParsedLockfile | null
+  config: ParsedCordoConfig | null
+  invoker: CordoInteraction | null
   idCounter: number
 }
 

package/src/core/routing/resolve.ts

@@ -1,3 +1,4 @@
+import { MissingContextError } from "../../errors/builtin/missing-context"
 import { Hooks } from "../hooks"
 import type { CordoInteraction } from "../interaction"
 import { CordoMagic } from "../magic"
@@ -60,6 +61,13 @@ export namespace RoutingResolve {
     const currentRoute = CordoMagic.getCwd()
     const invoker = CordoMagic.getInvoker()
 
+    if (!lockfile)
+      throw new MissingContextError('getRouteFromPath failed, no lockfile found in context.')
+    if (!currentRoute)
+      throw new MissingContextError('getRouteFromPath failed, no current route found in context.')
+    if (!invoker)
+      throw new MissingContextError('getRouteFromPath failed, no invoker found in context.')
+
     let startingPoint = currentRoute
     if (startingPoint.endsWith(DefaultFileName))
       startingPoint = startingPoint.slice(0, -DefaultFileName.length)
@@ -139,7 +147,7 @@ export namespace RoutingResolve {
   }
 
   export function getRouteFromId(routeId: string) {
-    return CordoMagic.getLockfile().$runtime.routeImpls.get(routeId)
+    return CordoMagic.getLockfile()?.$runtime.routeImpls.get(routeId)
   }
 
 }

package/src/errors/builtin/missing-context.ts

@@ -0,0 +1,13 @@
+import { CordoError } from "../cordo-error"
+
+
+export class MissingContextError extends CordoError {
+
+  constructor(public description: string) {
+    super(
+      'Missing context',
+      description
+    )
+  }
+
+}

package/src/errors/handle.ts

@@ -8,7 +8,10 @@ import { CordoError } from "./cordo-error"
 export namespace HandleErrors {
 
   function findApplicableBoundaries(startingPath: string) {
-    const errorBounds = CordoMagic.getLockfile().$runtime.errorBoundaries
+    const errorBounds = CordoMagic.getLockfile()?.$runtime.errorBoundaries
+    if (!errorBounds)
+      return []
+
     const routeFilePath = RoutingResolve.getRouteFromPath(startingPath, false).routeFilePath!
 
     const options = errorBounds.map(b => ({

package/src/functions/compiler.ts

@@ -1,6 +1,7 @@
 import { LockfileInternals } from "../core/files/lockfile"
 import { CordoMagic } from "../core/magic"
 import { RoutingResolve } from "../core/routing/resolve"
+import { MissingContextError } from "../errors/builtin/missing-context"
 import { LibIds } from "../lib/ids"
 import { LibUtils } from "../lib/utils"
 import { FunctInternals, type CordoFunct } from "./funct"
@@ -58,7 +59,10 @@ export namespace FunctCompiler {
     }
 
     // encode arguments
-    const lut = CordoMagic.getLockfile().lut
+    const lut = CordoMagic.getLockfile()?.lut
+    if (!lut)
+      throw new MissingContextError('toCustomId failed, no lockfile found in context.')
+    
     let argusStr = ''
     let counter = -1
     for (const arg of LibUtils.iterate(argus, extraValues)) {
@@ -91,7 +95,7 @@ export namespace FunctCompiler {
       return arg.slice(1)
 
     if (arg[0] === LutArgumentIndicator) 
-      return CordoMagic.getLockfile().lut[LibIds.parse(arg.slice(1))] ?? ''
+      return CordoMagic.getLockfile()?.lut[LibIds.parse(arg.slice(1))] ?? ''
 
     if (arg[0] === ReferenceArgumentIndicator) 
       return parsedArguments[LibIds.parseSingle(arg[1])] ?? ''

package/src/functions/impl/goto.ts

@@ -41,7 +41,7 @@ export function goto(
     ? FunctInternals.readFunct(path).path
     : path
 
-  const flags = parseFlags(opts, FunctInternals.readFunct(path as any)?.flags ?? CordoMagic.getConfig().functDefaultFlags.gotoBits)
+  const flags = parseFlags(opts, FunctInternals.readFunct(path as any)?.flags ?? CordoMagic.getConfig()?.functDefaultFlags.gotoBits ?? 0)
 
   return FunctInternals.createFunct({
     type: 'goto',

package/src/functions/impl/run.ts

@@ -58,7 +58,7 @@ export function run(
     ? FunctInternals.readFunct(path).path
     : path
 
-  const flags = parseFlags(opts, FunctInternals.readFunct(path as any)?.flags ?? CordoMagic.getConfig().functDefaultFlags.runBits)
+  const flags = parseFlags(opts, FunctInternals.readFunct(path as any)?.flags ?? CordoMagic.getConfig()?.functDefaultFlags.runBits ?? 0)
 
   return FunctInternals.createFunct({
     type: 'run',