@telorun/assert 0.1.3 → 0.1.5

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,17 @@
+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>;
+    }>;
+    resources: 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>>;
+    }>>>;
+    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,85 @@
+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()),
+    }),
+    resources: Type.Optional(Type.Record(Type.String(), ImportEntry)),
+    variables: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    secrets: Type.Optional(Type.Record(Type.String(), Type.Any())),
+});
+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 resourcesToCheck = manifest.resources ?? {};
+            const failures = [];
+            const passed = [];
+            const { resources } = ctx.moduleContext;
+            for (const [alias, expected] of Object.entries(resourcesToCheck)) {
+                if (!ctx.resolveModuleAlias(declaringModule, alias)) {
+                    failures.push(`Import alias '${alias}' not found in module '${declaringModule}'`);
+                    continue;
+                }
+                const snap = resources[alias] ?? {};
+                const path = `resources.${alias}`;
+                for (const [key, expectedValue] of Object.entries(expected.variables ?? {})) {
+                    const actual = snap?.variables?.[key];
+                    if (deepEqual(actual, expectedValue)) {
+                        passed.push(`${path}.variables.${key}`);
+                    }
+                    else {
+                        failures.push(`${path}.variables.${key}: expected ${yellow(JSON.stringify(expectedValue))}, got ${red(JSON.stringify(actual))}`);
+                    }
+                }
+                for (const [key, expectedValue] of Object.entries(expected.secrets ?? {})) {
+                    const actual = snap?.secrets?.[key];
+                    if (deepEqual(actual, expectedValue)) {
+                        passed.push(`${path}.secrets.${key}`);
+                    }
+                    else {
+                        failures.push(`${path}.secrets.${key}: ${dim("value mismatch")}`);
+                    }
+                }
+            }
+            const name = manifest.metadata.name;
+            const passedLines = passed.map((p) => `  ${green("✓")} ${dim(p)}\n`).join("");
+            if (failures.length > 0) {
+                const failedLines = failures.map((f) => `  ${red("✗")} ${f}\n`).join("");
+                process.stderr.write(bold(red(`Assert.ModuleContext.${name}: assertion failed`)) + "\n" + passedLines + failedLines);
+                ctx.requestExit(1);
+            }
+            else {
+                process.stdout.write(bold(green(`Assert.ModuleContext.${name}: assertion passed`)) + "\n" + passedLines);
+            }
+        },
+    };
+}

package/dist/schema.d.ts

@@ -1,6 +1,9 @@
 import { ResourceContext } from "@telorun/sdk";
 import { Static } from "@sinclair/typebox";
 export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
     schema: import("@sinclair/typebox").TObject<{
         type: import("@sinclair/typebox").TString;
     }>;

package/dist/schema.js

@@ -1,15 +1,32 @@
 import { Type } from "@sinclair/typebox";
 export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+    }),
     schema: Type.Object({
         type: Type.String(),
     }),
-}, {});
+});
+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 dim = (t) => c("2", t);
 export async function create(manifest, ctx) {
     const validator = ctx.createSchemaValidator(manifest.schema);
+    const name = manifest.metadata.name;
     return {
         invoke: (data) => {
-            validator.validate(data);
-            return true;
+            try {
+                validator.validate(data);
+                process.stdout.write(bold(green(`Assert.Schema.${name}: assertion passed`)) + "\n" + `  ${green("✓")} ${dim(JSON.stringify(data))}\n`);
+                return true;
+            }
+            catch (err) {
+                process.stderr.write(bold(red(`Assert.Schema.${name}: assertion failed`)) + "\n" + `  ${red("✗")} ${err?.message ?? String(err)}\n`);
+                throw err;
+            }
         },
     };
 }

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@telorun/assert",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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.6"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/value.js

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