@newhomestar/sdk 0.2.6 → 0.2.7

package/dist/index.d.ts

@@ -4,6 +4,10 @@ export interface ActionDef<I extends ZodTypeAny, O extends ZodTypeAny> {
     input: I;
     output: O;
     handler: (input: z.infer<I>, ctx: ActionCtx) => Promise<z.infer<O>>;
+    fga?: {
+        resourceType: string;
+        relation: string;
+    };
 }
 export interface ActionCtx {
     jobId: string;
@@ -13,6 +17,10 @@ export declare function action<I extends ZodTypeAny, O extends ZodTypeAny>(cfg:
     name?: string;
     input: I;
     output: O;
+    fga?: {
+        resourceType: string;
+        relation: string;
+    };
     handler: (input: z.infer<I>, ctx: ActionCtx) => Promise<z.infer<O>>;
 }): ActionDef<I, O>;
 export interface WorkerDef {
@@ -38,3 +46,5 @@ export type { ZodTypeAny as SchemaAny, ZodTypeAny };
 export declare function runHttpServer(def: WorkerDef, opts?: {
     port?: number;
 }): void;
+export { parseNovaSpec } from "./parseSpec";
+export type { NovaSpec } from "./parseSpec";

package/dist/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNovaSpec = void 0;
 exports.action = action;
 exports.defineWorker = defineWorker;
 exports.enqueue = enqueue;
@@ -114,9 +115,11 @@ function runHttpServer(def, opts = {}) {
     app.use(body_parser_1.default.json());
     for (const [actionName, act] of Object.entries(def.actions)) {
         const route = `/${def.name}/${actionName}`;
-        app.post(route, async (req, res) => {
+        // unified handler: parse JSON body or default to empty object
+        const handler = async (req, res) => {
             try {
-                const input = act.input.parse(req.body);
+                const payload = req.body && typeof req.body === 'object' ? req.body : {};
+                const input = act.input.parse(payload);
                 const ctx = { jobId: `http-${Date.now()}`, progress: () => { } };
                 const out = await act.handler(input, ctx);
                 act.output.parse(out);
@@ -125,10 +128,19 @@ function runHttpServer(def, opts = {}) {
             catch (err) {
                 res.status(400).json({ error: err.message });
             }
-        });
+        };
+        // POST /<worker>/<action>
+        app.post(route, handler);
+        // expose health under GET /health for liveness checks
+        if (actionName === 'health') {
+            app.get(`/${actionName}`, handler);
+        }
     }
     const port = opts.port ?? (process.env.PORT ? parseInt(process.env.PORT) : 3000);
     app.listen(port, () => {
         console.log(`[nova] HTTP server listening on http://localhost:${port}`);
     });
 }
+// YAML spec parsing utility
+var parseSpec_1 = require("./parseSpec");
+Object.defineProperty(exports, "parseNovaSpec", { enumerable: true, get: function () { return parseSpec_1.parseNovaSpec; } });

package/dist/parseSpec.d.ts

@@ -0,0 +1,444 @@
+import { z } from "zod";
+export declare const NovaSpecSchema: z.ZodObject<{
+    apiVersion: z.ZodString;
+    kind: z.ZodString;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        tags?: string[] | undefined;
+    }, {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        tags?: string[] | undefined;
+    }>;
+    spec: z.ZodObject<{
+        runtime: z.ZodObject<{
+            type: z.ZodString;
+            image: z.ZodString;
+            resources: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                cpu: string;
+                memory: string;
+            }, {
+                cpu: string;
+                memory: string;
+            }>;
+            command: z.ZodArray<z.ZodString, "many">;
+            queue: z.ZodString;
+            port: z.ZodNumber;
+            envSpec: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodOptional<z.ZodString>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }, {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        }, {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        }>;
+        actions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            async: z.ZodOptional<z.ZodBoolean>;
+            input: z.ZodOptional<z.ZodUnknown>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            schema: z.ZodOptional<z.ZodObject<{
+                input: z.ZodString;
+                output: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                input: string;
+                output: string;
+            }, {
+                input: string;
+                output: string;
+            }>>;
+            fga: z.ZodOptional<z.ZodObject<{
+                resourceType: z.ZodString;
+                relation: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                resourceType: string;
+                relation: string;
+            }, {
+                resourceType: string;
+                relation: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }, {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        runtime: {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        };
+        actions: {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }[];
+    }, {
+        runtime: {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        };
+        actions: {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }[];
+    }>;
+    build: z.ZodOptional<z.ZodObject<{
+        dockerfile: z.ZodString;
+        context: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        dockerfile: string;
+        context: string;
+    }, {
+        dockerfile: string;
+        context: string;
+    }>>;
+    ui: z.ZodOptional<z.ZodObject<{
+        category: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        category?: string | undefined;
+        color?: string | undefined;
+    }, {
+        category?: string | undefined;
+        color?: string | undefined;
+    }>>;
+    fga: z.ZodOptional<z.ZodObject<{
+        types: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            relations: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
+                computedUserset: z.ZodObject<{
+                    object: z.ZodString;
+                    relation: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    object: string;
+                    relation: string;
+                }, {
+                    object: string;
+                    relation: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }, {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }, {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        types: {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }[];
+    }, {
+        types: {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        tags?: string[] | undefined;
+    };
+    spec: {
+        runtime: {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        };
+        actions: {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }[];
+    };
+    fga?: {
+        types: {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }[];
+    } | undefined;
+    build?: {
+        dockerfile: string;
+        context: string;
+    } | undefined;
+    ui?: {
+        category?: string | undefined;
+        color?: string | undefined;
+    } | undefined;
+}, {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        tags?: string[] | undefined;
+    };
+    spec: {
+        runtime: {
+            type: string;
+            image: string;
+            resources: {
+                cpu: string;
+                memory: string;
+            };
+            command: string[];
+            queue: string;
+            port: number;
+            envSpec?: {
+                name: string;
+                value?: string | undefined;
+                secret?: boolean | undefined;
+                default?: string | undefined;
+            }[] | undefined;
+        };
+        actions: {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            async?: boolean | undefined;
+            input?: unknown;
+            output?: unknown;
+            schema?: {
+                input: string;
+                output: string;
+            } | undefined;
+            fga?: {
+                resourceType: string;
+                relation: string;
+            } | undefined;
+        }[];
+    };
+    fga?: {
+        types: {
+            name: string;
+            relations: Record<string, string[] | {
+                computedUserset: {
+                    object: string;
+                    relation: string;
+                };
+            }>;
+        }[];
+    } | undefined;
+    build?: {
+        dockerfile: string;
+        context: string;
+    } | undefined;
+    ui?: {
+        category?: string | undefined;
+        color?: string | undefined;
+    } | undefined;
+}>;
+export type NovaSpec = z.infer<typeof NovaSpecSchema>;
+/**
+ * Parse nova.yaml content and validate against the NovaSpec schema.
+ * Unknown fields are stripped; missing required fields throw an error.
+ * @param yamlContent String contents of a nova.yaml specification
+ * @returns Parsed NovaSpec object
+ * @throws Error with validation details if parsing or validation fail
+ */
+export declare function parseNovaSpec(yamlContent: string): NovaSpec;

package/dist/parseSpec.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NovaSpecSchema = void 0;
+exports.parseNovaSpec = parseNovaSpec;
+const yaml_1 = require("yaml");
+const zod_1 = require("zod");
+// Zod schema for nova.yaml
+exports.NovaSpecSchema = zod_1.z.object({
+    apiVersion: zod_1.z.string(),
+    kind: zod_1.z.string(),
+    metadata: zod_1.z.object({
+        name: zod_1.z.string(),
+        displayName: zod_1.z.string().optional(),
+        description: zod_1.z.string().optional(),
+        icon: zod_1.z.string().optional(),
+        tags: zod_1.z.array(zod_1.z.string()).optional(),
+    }),
+    spec: zod_1.z.object({
+        runtime: zod_1.z.object({
+            type: zod_1.z.string(),
+            image: zod_1.z.string(),
+            resources: zod_1.z.object({
+                cpu: zod_1.z.string(),
+                memory: zod_1.z.string(),
+            }),
+            command: zod_1.z.array(zod_1.z.string()),
+            queue: zod_1.z.string(),
+            port: zod_1.z.number(),
+            envSpec: zod_1.z.array(zod_1.z.object({
+                name: zod_1.z.string(),
+                value: zod_1.z.string().optional(),
+                secret: zod_1.z.boolean().optional(),
+                default: zod_1.z.string().optional(),
+            })).optional(),
+        }),
+        actions: zod_1.z.array(zod_1.z.object({
+            name: zod_1.z.string(),
+            displayName: zod_1.z.string().optional(),
+            description: zod_1.z.string().optional(),
+            icon: zod_1.z.string().optional(),
+            async: zod_1.z.boolean().optional(),
+            input: zod_1.z.unknown().optional(), // JSON schema object
+            output: zod_1.z.unknown().optional(), // JSON schema object
+            schema: zod_1.z.object({
+                input: zod_1.z.string(),
+                output: zod_1.z.string(),
+            }).optional(),
+            fga: zod_1.z.object({
+                resourceType: zod_1.z.string(),
+                relation: zod_1.z.string(),
+            }).optional(),
+        })),
+    }),
+    build: zod_1.z.object({
+        dockerfile: zod_1.z.string(),
+        context: zod_1.z.string(),
+    }).optional(),
+    ui: zod_1.z.object({
+        category: zod_1.z.string().optional(),
+        color: zod_1.z.string().optional(),
+    }).optional(),
+    // OpenFGA policy hints embedded in nova.yaml
+    fga: zod_1.z.object({
+        types: zod_1.z.array(zod_1.z.object({
+            name: zod_1.z.string(),
+            relations: zod_1.z.record(zod_1.z.string(), zod_1.z.union([
+                zod_1.z.array(zod_1.z.string()),
+                zod_1.z.object({
+                    computedUserset: zod_1.z.object({
+                        object: zod_1.z.string(),
+                        relation: zod_1.z.string(),
+                    }),
+                }),
+            ])),
+        })),
+    }).optional(),
+}).strict();
+/**
+ * Parse nova.yaml content and validate against the NovaSpec schema.
+ * Unknown fields are stripped; missing required fields throw an error.
+ * @param yamlContent String contents of a nova.yaml specification
+ * @returns Parsed NovaSpec object
+ * @throws Error with validation details if parsing or validation fail
+ */
+function parseNovaSpec(yamlContent) {
+    let parsed;
+    try {
+        parsed = (0, yaml_1.parse)(yamlContent);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse YAML content: ${e.message}`);
+    }
+    try {
+        return exports.NovaSpecSchema.parse(parsed);
+    }
+    catch (e) {
+        if (e instanceof zod_1.z.ZodError) {
+            const details = e.errors
+                .map(err => `Path '${err.path.join(".")}': ${err.message}`)
+                .join("; ");
+            throw new Error(`nova.yaml validation error(s): ${details}`);
+        }
+        throw e;
+    }
+}

package/package.json

@@ -1,35 +1,36 @@
-{
-  "name": "@newhomestar/sdk",
-  "version": "0.2.6",
-  "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
-  "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
-  "bugs": {
-    "url": "https://github.com/newhomestar/nova-node-sdk/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/newhomestar/nova-node-sdk.git"
-  },
-  "license": "ISC",
-  "author": "Christian Gomez",
-  "type": "commonjs",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "@supabase/supabase-js": "^2.39.0",
-    "dotenv": "^16.4.3",
-    "zod": "^3.23.8",
-    "express": "^4.18.2",
-    "body-parser": "^1.20.2"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.17",
-    "typescript": "^5.4.4"
-  }
-}
+{
+  "name": "@newhomestar/sdk",
+  "version": "0.2.7",
+  "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
+  "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/newhomestar/nova-node-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/newhomestar/nova-node-sdk.git"
+  },
+  "license": "ISC",
+  "author": "Christian Gomez",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0",
+    "dotenv": "^16.4.3",
+    "zod": "^3.23.8",
+    "express": "^4.18.2",
+    "body-parser": "^1.20.2",
+    "yaml": "^2.7.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "typescript": "^5.4.4"
+  }
+}