@telorun/assert 0.1.3 → 0.1.4

package/dist/events.d.ts

@@ -13,5 +13,7 @@ export declare const schema: import("@sinclair/typebox").TObject<{
     }>>;
 }>;
 type AssertManifest = Static<typeof schema>;
-export declare function create(manifest: AssertManifest, ctx: ResourceContext): Promise<{}>;
+export declare function create(manifest: AssertManifest, ctx: ResourceContext): Promise<{
+    run: () => Promise<void>;
+}>;
 export {};

package/dist/events.js

@@ -102,22 +102,27 @@ function buildReport(name, captured, expect) {
 export async function create(manifest, ctx) {
     const captured = [];
     const filters = manifest.filter ?? [{ type: "*" }];
+    let appStarted = false;
+    ctx.on("Kernel.Started", () => {
+        appStarted = true;
+    });
     ctx.on("*", (event) => {
         if (filters.some((f) => matchesPattern(f.type, event.name))) {
             captured.push({ name: event.name, payload: event.payload });
         }
     });
-    ctx.on("Runtime.Stopping", () => {
-        const report = buildReport(manifest.metadata.name, captured, manifest.expect);
-        if (report) {
-            if (report.passed) {
-                process.stdout.write(report.report);
-            }
-            else {
-                process.stderr.write(report.report);
-                ctx.requestExit(1);
+    return {
+        run: async () => {
+            const report = buildReport(manifest.metadata.name, captured, manifest.expect);
+            if (report) {
+                if (report.passed) {
+                    process.stdout.write(report.report);
+                }
+                else {
+                    process.stderr.write(report.report);
+                    ctx.requestExit(1);
+                }
             }
-        }
-    });
-    return {};
+        },
+    };
 }

package/dist/module-context.d.ts

@@ -0,0 +1,15 @@
+import { Static } from "@sinclair/typebox";
+import { ResourceContext, Runnable } from "@telorun/sdk";
+export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        module: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    imports: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        variables: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+        secrets: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    }>>>;
+}>;
+type ModuleContextManifest = Static<typeof schema>;
+export declare function create(manifest: ModuleContextManifest, ctx: ResourceContext): Promise<Runnable>;
+export {};

package/dist/module-context.js

@@ -0,0 +1,94 @@
+import { Type } from "@sinclair/typebox";
+const ImportEntry = Type.Object({
+    variables: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    secrets: Type.Optional(Type.Record(Type.String(), Type.Any())),
+});
+export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+        module: Type.Optional(Type.String()),
+    }),
+    imports: Type.Optional(Type.Record(Type.String(), ImportEntry)),
+});
+const useColor = process.stderr.isTTY;
+const c = (code, text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+const bold = (t) => c("1", t);
+const red = (t) => c("31", t);
+const green = (t) => c("32", t);
+const yellow = (t) => c("33", t);
+const dim = (t) => c("2", t);
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+export async function create(manifest, ctx) {
+    return {
+        run: async () => {
+            const declaringModule = manifest.metadata.module ?? "default";
+            const importsToCheck = manifest.imports ?? {};
+            const failures = [];
+            const passed = [];
+            for (const [alias, expected] of Object.entries(importsToCheck)) {
+                const realModule = ctx.resolveModuleAlias(declaringModule, alias);
+                if (!realModule) {
+                    failures.push(`Import alias '${alias}' not found in module '${declaringModule}'`);
+                    continue;
+                }
+                const moduleCtx = ctx.moduleContext;
+                const importSnap = moduleCtx.resources[alias] ?? {};
+                const expectedVariables = expected.variables ?? {};
+                const expectedSecrets = expected.secrets ?? {};
+                for (const [key, expectedValue] of Object.entries(expectedVariables)) {
+                    const actualValue = importSnap?.variables?.[key];
+                    if (!deepEqual(actualValue, expectedValue)) {
+                        failures.push(`imports.${alias}.variables.${key}: expected ${yellow(JSON.stringify(expectedValue))}, got ${red(JSON.stringify(actualValue))}`);
+                    }
+                    else {
+                        passed.push(`imports.${alias}.variables.${key}`);
+                    }
+                }
+                for (const [key] of Object.entries(expectedSecrets)) {
+                    const actualSecret = importSnap?.secrets?.[key];
+                    if (!deepEqual(actualSecret, expectedSecrets[key])) {
+                        failures.push(`imports.${alias}.secrets.${key}: ${dim("value mismatch")}`);
+                    }
+                    else {
+                        passed.push(`imports.${alias}.secrets.${key}`);
+                    }
+                }
+            }
+            const name = manifest.metadata.name;
+            if (failures.length > 0) {
+                let report = bold(red(`Assert.ModuleContext.${name}: assertion failed`)) + "\n";
+                for (const p of passed) {
+                    report += `  ${green("✓")} ${dim(p)}\n`;
+                }
+                for (const f of failures) {
+                    report += `  ${red("✗")} ${f}\n`;
+                }
+                process.stderr.write(report);
+                ctx.requestExit(1);
+            }
+            else {
+                let report = bold(green(`Assert.ModuleContext.${name}: assertion passed`)) + "\n";
+                for (const p of passed) {
+                    report += `  ${green("✓")} ${dim(p)}\n`;
+                }
+                process.stdout.write(report);
+            }
+        },
+    };
+}

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@telorun/assert",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "exports": {
     "./schema": "./src/schema.ts",
-    "./events": "./src/events.ts"
+    "./events": "./src/events.ts",
+    "./module-context": "./src/module-context.ts"
   },
   "files": [
     "dist/**"
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "@telorun/sdk": "0.2.4"
+    "@telorun/sdk": "0.2.5"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/value.js

@@ -1,3 +0,0 @@
-export async function create() {
-    return {};
-}