@olenbetong/appframe-vite 6.2.0 → 6.3.1

package/lib/cli-resources-add.js

@@ -159,7 +159,15 @@ export async function addResource() {
         expose: exposeIt || undefined,
         permissions: permissions,
         maxRecords: maxRecords !== "50" ? Number(maxRecords) : undefined,
-        sortOrder: sortOrder ? sortOrder.split(",") : undefined,
+        sortOrder: sortOrder
+            ? sortOrder
+                .split(",")
+                .filter(Boolean)
+                .map((s) => {
+                const [field, direction] = s.split(":");
+                return direction ? { field, direction } : { field };
+            })
+            : undefined,
         fields: selectedFields.length > 0 ? selectedFields : undefined,
     };
     // Write to resources.yaml

package/lib/cli-resources-edit.js

@@ -153,7 +153,15 @@ export async function editResource(id) {
         expose: exposeIt || undefined,
         permissions,
         maxRecords: maxRecords !== "50" ? Number(maxRecords) : undefined,
-        sortOrder: sortOrder ? sortOrder.split(",") : undefined,
+        sortOrder: sortOrder
+            ? sortOrder
+                .split(",")
+                .filter(Boolean)
+                .map((s) => {
+                const [field, direction] = s.split(":");
+                return direction ? { field, direction } : { field };
+            })
+            : undefined,
         fields: selectedFields.length > 0 ? selectedFields : undefined,
     };
     // Update resources.yaml

package/lib/cli-resources-generate.js

@@ -22,10 +22,10 @@ export async function generateFromConfig(configPath) {
     let errors = [];
     for (let { entry } of allEntries) {
         let options = entryToCLIOptions(entry, resourcesConfig.server ?? hostname);
-        options.output = resolve(process.cwd(), entry.output);
+        options.output = resolve(process.cwd(), entry.output ?? `src/data/${entry.id}.ts`);
         try {
             let content = await fetchAndGenerate(entry.resource, options, client);
-            let outputPath = resolve(process.cwd(), entry.output);
+            let outputPath = resolve(process.cwd(), entry.output ?? `src/data/${entry.id}.ts`);
             await mkdir(dirname(outputPath), { recursive: true });
             await writeFile(outputPath, content, "utf-8");
             await formatWithBiome(outputPath);
@@ -38,7 +38,6 @@ export async function generateFromConfig(configPath) {
         }
     }
     if (errors.length > 0) {
-        console.error(`\n${errors.length} resource(s) failed to generate.`);
-        process.exit(1);
+        throw new Error(`${errors.length} resource(s) failed to generate:\n${errors.map((e) => `  ${e.id}: ${e.error}`).join("\n")}`);
     }
 }

package/lib/cli.js

@@ -34,7 +34,13 @@ resources
     .option("-c, --config <path>", "Path to resources config file (default: resources.yaml)")
     .action(async (opts) => {
     let { generateFromConfig } = await import("./cli-resources-generate.js");
-    await generateFromConfig(opts.config);
+    try {
+        await generateFromConfig(opts.config);
+    }
+    catch (error) {
+        console.error(`\n${error?.message ?? error}`);
+        process.exit(1);
+    }
 });
 resources
     .command("add")

package/lib/devtoolsServer.d.ts

@@ -0,0 +1,7 @@
+import type { Connect } from "vite";
+/**
+ * Creates a Connect middleware that:
+ * 1. Serves the appframe-devtools static SPA at `/__appframe_devtools__/`
+ * 2. Exposes a REST API at `/__appframe_devtools__/api/resources` for resources.yaml CRUD
+ */
+export declare function createDevtoolsMiddleware(hostname: string): Connect.NextHandleFunction;

package/lib/devtoolsServer.js

@@ -0,0 +1,240 @@
+import { createReadStream, existsSync, rmSync } from "node:fs";
+import https from "node:https";
+import { createRequire } from "node:module";
+import { dirname, extname, join } from "node:path";
+import bodyParser from "body-parser";
+import { login } from "./proxy.js";
+import { readResourcesConfig, writeResourcesConfig } from "./resourcesConfig.js";
+const require = createRequire(import.meta.url);
+const ALL_SERVERS = ["dev.obet.no", "stage.obet.no", "test.obet.no"];
+const MIME_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+};
+function getDevtoolsDist() {
+    try {
+        const pkgPath = require.resolve("@olenbetong/appframe-devtools/package.json");
+        return join(dirname(pkgPath), "dist");
+    }
+    catch {
+        return null;
+    }
+}
+function sendJson(res, status, data) {
+    const body = status === 204 ? "" : JSON.stringify(data);
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(body);
+}
+async function addResourceOnServer(hostname, cookies, dbObjectId, name) {
+    const cookieStr = Object.entries(cookies)
+        .map(([k, v]) => `${k}=${v}`)
+        .join("; ");
+    // Name is required by the server; fall back to the DBObjectID itself
+    const body = JSON.stringify({
+        operation: "create",
+        resourceName: "API_Resources",
+        // fields + excludeFieldNames match the format generateApiDataHandler sends, which the server requires
+        fields: ["PrimKey", "Created", "CreatedBy", "Updated", "UpdatedBy", "CUT", "CDL", "DBObjectID", "Name"],
+        excludeFieldNames: true,
+        DBObjectID: dbObjectId,
+        Name: name ?? dbObjectId,
+    });
+    return new Promise((resolve) => {
+        const req = https.request({
+            hostname,
+            port: 443,
+            path: "/api/data",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Cookie: cookieStr,
+                Origin: `https://${hostname}`,
+                "Content-Length": Buffer.byteLength(body),
+            },
+        }, (incoming) => {
+            let raw = "";
+            incoming.on("data", (chunk) => {
+                raw += chunk;
+            });
+            incoming.on("end", () => {
+                try {
+                    const json = JSON.parse(raw);
+                    if (json.error) {
+                        resolve({ hostname, success: false, error: json.error });
+                    }
+                    else {
+                        resolve({ hostname, success: true });
+                    }
+                }
+                catch {
+                    const ok = (incoming.statusCode ?? 0) < 400;
+                    resolve({ hostname, success: ok, error: ok ? undefined : raw.slice(0, 200) });
+                }
+            });
+        });
+        req.on("error", (err) => resolve({ hostname, success: false, error: err.message }));
+        req.write(body);
+        req.end();
+    });
+}
+async function handleApi(req, res, apiPath, hostname, next) {
+    // apiPath is the path after /__appframe_devtools__/api
+    // e.g. /config, /resources or /resources/dsMyObject
+    const segments = apiPath
+        .replace(/^\/resources/, "")
+        .split("/")
+        .filter(Boolean);
+    const method = req.method?.toUpperCase() ?? "GET";
+    if (apiPath === "/config" && method === "GET") {
+        return sendJson(res, 200, { hostname });
+    }
+    // Only handle /resources and /resources/:id
+    if (!apiPath.startsWith("/resources") && apiPath !== "/catalog") {
+        return next();
+    }
+    const id = segments[0]; // undefined for collection-level routes
+    try {
+        if (apiPath === "/catalog" && method === "POST") {
+            const { dbObjectId, name } = req.body;
+            if (!dbObjectId) {
+                return sendJson(res, 400, { error: "dbObjectId is required" });
+            }
+            const username = process.env.APPFRAME_LOGIN ?? "";
+            const password = process.env.APPFRAME_PWD ?? "";
+            if (!username || !password) {
+                return sendJson(res, 500, { error: "APPFRAME_LOGIN and APPFRAME_PWD environment variables must be set" });
+            }
+            const settled = await Promise.allSettled(ALL_SERVERS.map(async (server) => {
+                const cookies = await login(server, username, password, { silent: true });
+                return addResourceOnServer(server, cookies, dbObjectId, name);
+            }));
+            const results = settled.map((r, i) => r.status === "fulfilled"
+                ? r.value
+                : { hostname: ALL_SERVERS[i], success: false, error: String(r.reason) });
+            return sendJson(res, 200, { results });
+        }
+        if (method === "GET" && !id) {
+            const config = await readResourcesConfig();
+            return sendJson(res, 200, config);
+        }
+        if (method === "POST" && !id) {
+            const { type, ...entry } = req.body;
+            const config = await readResourcesConfig();
+            if (type === "procedure") {
+                config.procedures = [...(config.procedures ?? []), entry];
+            }
+            else {
+                config.dataObjects = [...(config.dataObjects ?? []), entry];
+            }
+            await writeResourcesConfig(config);
+            return sendJson(res, 201, entry);
+        }
+        if (method === "PUT" && id) {
+            const updates = req.body;
+            const config = await readResourcesConfig();
+            let found = false;
+            for (const list of [config.dataObjects ?? [], config.procedures ?? []]) {
+                const idx = list.findIndex((e) => e.id === id);
+                if (idx !== -1) {
+                    list[idx] = { ...list[idx], ...updates };
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return sendJson(res, 404, { error: `Resource '${id}' not found` });
+            }
+            await writeResourcesConfig(config);
+            return sendJson(res, 200, { id, ...updates });
+        }
+        if (method === "DELETE" && id) {
+            const config = await readResourcesConfig();
+            let found = false;
+            let outputPath;
+            for (const key of ["dataObjects", "procedures"]) {
+                const list = config[key] ?? [];
+                const idx = list.findIndex((e) => e.id === id);
+                if (idx !== -1) {
+                    outputPath = list[idx].output;
+                    list.splice(idx, 1);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return sendJson(res, 404, { error: `Resource '${id}' not found` });
+            }
+            await writeResourcesConfig(config);
+            if (outputPath) {
+                try {
+                    rmSync(outputPath, { force: true });
+                }
+                catch {
+                    // non-fatal — file may not exist yet
+                }
+            }
+            return sendJson(res, 204, null);
+        }
+        return next();
+    }
+    catch (err) {
+        return sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+    }
+}
+/**
+ * Creates a Connect middleware that:
+ * 1. Serves the appframe-devtools static SPA at `/__appframe_devtools__/`
+ * 2. Exposes a REST API at `/__appframe_devtools__/api/resources` for resources.yaml CRUD
+ */
+export function createDevtoolsMiddleware(hostname) {
+    const jsonParser = bodyParser.json();
+    const devtoolsDist = getDevtoolsDist();
+    return (req, res, next) => {
+        // req.url here is the path after /__appframe_devtools__ (Connect strips the prefix)
+        const url = req.url ?? "/";
+        // REST API
+        if (url.startsWith("/api/")) {
+            jsonParser(req, res, () => {
+                handleApi(req, res, url.slice(4), hostname, next).catch(next);
+            });
+            return;
+        }
+        // Static files
+        if (!devtoolsDist) {
+            res.statusCode = 503;
+            res.setHeader("Content-Type", "text/plain");
+            res.end("@olenbetong/appframe-devtools not found or not built.\n" +
+                "Run: pnpm --filter @olenbetong/appframe-devtools build");
+            return;
+        }
+        const safePath = url.split("?")[0] || "/";
+        const filePath = join(devtoolsDist, safePath === "/" ? "index.html" : safePath);
+        if (existsSync(filePath)) {
+            const mime = MIME_TYPES[extname(filePath)] ?? "application/octet-stream";
+            res.setHeader("Content-Type", mime);
+            createReadStream(filePath).pipe(res);
+        }
+        else {
+            // SPA fallback - all unknown paths serve index.html
+            const indexPath = join(devtoolsDist, "index.html");
+            if (existsSync(indexPath)) {
+                res.setHeader("Content-Type", "text/html; charset=utf-8");
+                createReadStream(indexPath).pipe(res);
+            }
+            else {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "text/plain");
+                res.end("DevTools app not built yet.\n" + "Run: pnpm --filter @olenbetong/appframe-devtools build");
+            }
+        }
+    };
+}

package/lib/index.d.ts

@@ -1,5 +1,15 @@
 import type { Plugin } from "vite";
 import { addAppframeBuildConfig } from "./build.js";
 import { createDevMiddleware } from "./devServer.js";
-export default function appframe(): Plugin;
+export interface AppframePluginOptions {
+    /**
+     * Whether to automatically generate TypeScript types from the Appframe article
+     * when the dev server starts. Set to `false` to skip type generation (e.g. when
+     * running Storybook or another tool that doesn't have an article context).
+     *
+     * @default true
+     */
+    generateTypes?: boolean;
+}
+export default function appframe(options?: AppframePluginOptions): Plugin;
 export { addAppframeBuildConfig, createDevMiddleware };

package/lib/index.js

@@ -4,6 +4,7 @@ import { watch } from "chokidar";
 import { addAppframeBuildConfig } from "./build.js";
 import { generateFromConfig } from "./cli-resources-generate.js";
 import { createDevMiddleware, getLoginInfo, getProxyRoutes } from "./devServer.js";
+import { createDevtoolsMiddleware } from "./devtoolsServer.js";
 import { runGenerateTypes } from "./generateTypes.js";
 import { localizeMiddleware } from "./localization.js";
 import { checkSession, getLastSession, login } from "./proxy.js";
@@ -31,7 +32,8 @@ catch (error) {
     console.log(createLogMessage(`failed to watch package.json: ${error.message}`, { type: "warn" }));
 }
 const jsonParser = bodyParser.json();
-export default function appframe() {
+export default function appframe(options = {}) {
+    let { generateTypes = true } = options;
     return {
         name: "appframe",
         resolveId(source) {
@@ -143,7 +145,9 @@ export default function appframe() {
             let { appframe, hostname, username, password } = await getLoginInfo();
             server = _server;
             // Run type generation in the background — doesn't block the dev server from starting.
-            runGenerateTypes(hostname, username, password, appframe, _server.config.logger);
+            if (generateTypes) {
+                runGenerateTypes(hostname, username, password, appframe, _server.config.logger);
+            }
             // Watch resources.yaml and regenerate on change
             let resourcesConfigPath = resolve(process.cwd(), RESOURCES_CONFIG_FILE);
             if (resourcesWatcher) {
@@ -166,6 +170,8 @@ export default function appframe() {
                     }
                 }, 300);
             });
+            // DevTools panel: serve the devtools app + REST API at /__appframe_devtools__/
+            _server.middlewares.use("/__appframe_devtools__", createDevtoolsMiddleware(hostname));
             _server.middlewares.use(`/api/user/localize/new/${appframe.article.id}`, jsonParser);
             _server.middlewares.use(`/api/user/localize/new/${appframe.article.id}`, localizeMiddleware);
             _server.middlewares.use("/data/Logger/LogError", jsonParser);
@@ -182,6 +188,21 @@ export default function appframe() {
                 _server.middlewares.use(createDevMiddleware(_server));
             };
         },
+        transformIndexHtml(_html, ctx) {
+            // Only inject the toolbar in dev mode
+            if (command !== "serve")
+                return;
+            // Only inject for article pages (not the devtools app itself)
+            if (ctx.originalUrl?.startsWith("/__appframe_devtools__"))
+                return;
+            return [
+                {
+                    tag: "script",
+                    attrs: { src: "/__appframe_devtools__/toolbar.js", defer: true },
+                    injectTo: "body",
+                },
+            ];
+        },
     };
 }
 export { addAppframeBuildConfig, createDevMiddleware };

package/lib/resourceGenerate.js

@@ -320,7 +320,7 @@ export function getProcedureDefinition(name, procDefinition, options) {
             output.push(`export type ${paramTypeName} = null | undefined | Record<string, unknown>;\n`);
         }
     }
-    output.push(`export const ${procName} = new ${options.global ? "af." : ""}ProcedureAPI${options.types ? `<${paramTypeName}, ${options.typesJsonReturnType ?? "unknown"}>` : ""}({
+    output.push(`export const ${procName} = new ${options.global ? "af." : ""}ProcedureAPI${options.types ? `<${paramTypeName}, ${options.typesJsonReturnType ?? "{ Table?: unknown[] }"}>` : ""}({
   procedureId: "${name}",
   parameters: ${JSON.stringify(parameters, null, 2)},
   timeout: 30000
@@ -539,7 +539,8 @@ export async function fetchResourceDefinition(client, resourceName) {
     if (!response.ok) {
         throw new Error(`Failed to fetch resource definition for '${resourceName}': ${response.status} ${response.statusText}`);
     }
-    return response.json();
+    const json = await response.json();
+    return json.success ?? json;
 }
 /**
  * Fetch the resource definition from the server, read types.json overrides, and
@@ -551,7 +552,7 @@ export async function fetchResourceDefinition(client, resourceName) {
  */
 export async function fetchAndGenerate(resourceName, options, client) {
     let definition = await fetchResourceDefinition(client, resourceName);
-    definition.Parameters = definition.Parameters.filter((p) => !["CUT", "CDL"].includes(p.Name));
+    definition.Parameters = (definition.Parameters ?? []).filter((p) => !["CUT", "CDL"].includes(p.Name));
     let typesJson = {};
     try {
         typesJson = await importJson("./types.json", true);
@@ -560,7 +561,8 @@ export async function fetchAndGenerate(resourceName, options, client) {
         // no types.json — that's fine
     }
     options.typesJsonParamOverrides = typesJson.parameterTypes?.[resourceName] ?? {};
-    options.typesJsonReturnType = typesJson.procedureReturnTypes?.[resourceName] ?? null;
+    // Structured returnType from resources.yaml takes precedence over the raw types.json string
+    options.typesJsonReturnType = options.typesJsonReturnType ?? typesJson.procedureReturnTypes?.[resourceName] ?? null;
     return definition.ObjectType === "V"
         ? getDataObjectDefinition(resourceName, definition, options)
         : getProcedureDefinition(resourceName, definition, options);

package/lib/resourcesConfig.d.ts

@@ -1,4 +1,24 @@
 import type { CLIOptions } from "./resourceGenerate.js";
+export type ReturnTypeField = {
+    /** TypeScript field name */
+    name: string;
+    /** TypeScript type, e.g. `string`, `number | null`, `Date` */
+    type: string;
+};
+export type ReturnTypeTable = {
+    /** Property key when multiple result-sets are returned. Omit for single-table procedures. */
+    table?: string;
+    fields: ReturnTypeField[];
+};
+/**
+ * Build an inline TypeScript type string from a structured returnType definition.
+ *
+ * The server always returns a DataSet serialized as `{ Table: T[], Table1: U[], ... }`.
+ * The first table is always `"Table"`, subsequent ones are `"Table1"`, `"Table2"`, etc.
+ * An explicit `table` name on the entry overrides the auto-generated key (for procedures
+ * that assign custom DataTable.TableName values).
+ */
+export declare function returnTypeToString(returnType: ReturnTypeTable[]): string;
 export type ResourceEntry = {
     /** Data object or procedure identifier used in the generated code (e.g. `dsAccountGroups`) */
     id: string;
@@ -14,8 +34,11 @@ export type ResourceEntry = {
     permissions?: string;
     /** Maximum records to fetch (default `50`; use `-1` for all) */
     maxRecords?: number;
-    /** Sort order: comma-separated list of `field` or `field:Asc|Desc` */
-    sortOrder?: string | string[];
+    /** Sort order as a list of sort objects */
+    sortOrder?: Array<{
+        field: string;
+        direction?: string;
+    }>;
     /** Name of master data object (optionally `name:importPath` to import from another file) */
     master?: string;
     /** Link fields to master data object (comma-separated or array) */
@@ -30,14 +53,19 @@ export type ResourceEntry = {
     overrides?: string | string[];
     /** Fetch distinct rows */
     distinct?: boolean;
-    /** Aggregate bindings for non-grouped fields: comma-separated or array of `field:AGG` */
-    aggregates?: string | string[];
-    /** Group-by fields: comma-separated or array */
-    groupBy?: string | string[];
+    /** Aggregate bindings for non-grouped fields */
+    aggregates?: Array<{
+        field: string;
+        aggregate: string;
+    }>;
+    /** Group-by fields */
+    groupBy?: string[];
     /** Initial where clause */
     where?: string;
     /** Fields to include: comma-separated or array of field names */
     fields?: string | string[];
+    /** Structured return type definition for procedures (generates inline TS type) */
+    returnType?: ReturnTypeTable[];
 };
 export type ResourcesConfig = {
     /** Optional server hostname override (defaults to `appframe.proxy.hostname` from package.json) */

package/lib/resourcesConfig.js

@@ -2,6 +2,34 @@ import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+/**
+ * Build an inline TypeScript type string from a structured returnType definition.
+ *
+ * The server always returns a DataSet serialized as `{ Table: T[], Table1: U[], ... }`.
+ * The first table is always `"Table"`, subsequent ones are `"Table1"`, `"Table2"`, etc.
+ * An explicit `table` name on the entry overrides the auto-generated key (for procedures
+ * that assign custom DataTable.TableName values).
+ */
+export function returnTypeToString(returnType) {
+    if (returnType.length === 0) {
+        return "unknown";
+    }
+    function tableRowType(table) {
+        if (table.fields.length === 0) {
+            return "Record<string, unknown>";
+        }
+        let props = table.fields.map((f) => `${f.name}: ${f.type}`).join("; ");
+        return `{ ${props} }`;
+    }
+    function tableKey(table, index) {
+        if (table.table) {
+            return table.table;
+        }
+        return index === 0 ? "Table" : `Table${index}`;
+    }
+    let props = returnType.map((t, i) => `${tableKey(t, i)}: ${tableRowType(t)}[]`).join("; ");
+    return `{ ${props} }`;
+}
 // ---------------------------------------------------------------------------
 // Config file path
 // ---------------------------------------------------------------------------
@@ -35,6 +63,32 @@ function arrayOrStringToString(value) {
         return value.join(",");
     return value;
 }
+/** Convert sortOrder (new object format, old string/array) to comma-separated CLIOptions string. */
+function sortOrderToString(sortOrder) {
+    if (!sortOrder)
+        return undefined;
+    if (typeof sortOrder === "string")
+        return sortOrder;
+    if (Array.isArray(sortOrder) && sortOrder.length === 0)
+        return undefined;
+    if (typeof sortOrder[0] === "string")
+        return sortOrder.join(",");
+    return sortOrder
+        .map((s) => (s.direction ? `${s.field}:${s.direction}` : s.field))
+        .join(",");
+}
+/** Convert aggregates (new object format, old string/array) to comma-separated CLIOptions string. */
+function aggregatesToString(aggregates) {
+    if (!aggregates)
+        return undefined;
+    if (typeof aggregates === "string")
+        return aggregates;
+    if (Array.isArray(aggregates) && aggregates.length === 0)
+        return undefined;
+    if (typeof aggregates[0] === "string")
+        return aggregates.join(",");
+    return aggregates.map((a) => `${a.field}:${a.aggregate}`).join(",");
+}
 /** Convert a `ResourceEntry` into a `CLIOptions`-compatible object for code generation. */
 export function entryToCLIOptions(entry, hostname) {
     return {
@@ -44,7 +98,7 @@ export function entryToCLIOptions(entry, hostname) {
         dynamic: entry.dynamic ?? false,
         types: entry.types,
         maxRecords: entry.maxRecords !== undefined ? String(entry.maxRecords) : "50",
-        sortOrder: arrayOrStringToString(entry.sortOrder),
+        sortOrder: sortOrderToString(entry.sortOrder),
         permissions: entry.permissions,
         master: entry.master,
         linkFields: arrayOrStringToString(entry.linkFields),
@@ -52,11 +106,12 @@ export function entryToCLIOptions(entry, hostname) {
         unique: entry.unique,
         overrides: arrayOrStringToString(entry.overrides),
         distinct: entry.distinct,
-        aggregates: arrayOrStringToString(entry.aggregates),
-        groupBy: arrayOrStringToString(entry.groupBy),
+        aggregates: aggregatesToString(entry.aggregates),
+        groupBy: entry.groupBy?.join(","),
         where: entry.where,
         fields: arrayOrStringToString(entry.fields) ?? false,
-        output: resolve(process.cwd(), entry.output),
+        output: resolve(process.cwd(), entry.output ?? `src/data/${entry.id}.ts`),
+        typesJsonReturnType: entry.returnType ? returnTypeToString(entry.returnType) : undefined,
     };
 }
 /** Convert a `CLIOptions` back to a `ResourceEntry` for saving to YAML. */
@@ -81,8 +136,15 @@ export function cliOptionsToEntry(resource, options) {
     if (options.maxRecords && options.maxRecords !== "50") {
         entry.maxRecords = Number(options.maxRecords);
     }
-    if (options.sortOrder)
-        entry.sortOrder = maybeArray(options.sortOrder) ?? options.sortOrder;
+    if (options.sortOrder) {
+        entry.sortOrder = options.sortOrder
+            .split(",")
+            .filter(Boolean)
+            .map((s) => {
+            const [field, direction] = s.split(":");
+            return direction ? { field, direction } : { field };
+        });
+    }
     if (options.master)
         entry.master = options.master;
     if (options.linkFields)
@@ -97,10 +159,17 @@ export function cliOptionsToEntry(resource, options) {
         entry.overrides = maybeArray(options.overrides) ?? options.overrides;
     if (options.distinct)
         entry.distinct = true;
-    if (options.aggregates)
-        entry.aggregates = maybeArray(options.aggregates) ?? options.aggregates;
+    if (options.aggregates) {
+        entry.aggregates = options.aggregates
+            .split(",")
+            .filter(Boolean)
+            .map((a) => {
+            const [field, aggregate] = a.split(":");
+            return { field, aggregate: aggregate ?? "" };
+        });
+    }
     if (options.groupBy)
-        entry.groupBy = maybeArray(options.groupBy) ?? options.groupBy;
+        entry.groupBy = options.groupBy.split(",").filter(Boolean);
     if (options.where)
         entry.where = options.where;
     if (options.fields && typeof options.fields === "string") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olenbetong/appframe-vite",
-  "version": "6.2.0",
+  "version": "6.3.1",
   "description": "Tools to use and deploy Vite applications to Appframe",
   "main": "./lib/index.js",
   "type": "module",
@@ -29,24 +29,25 @@
   "author": "Bjørnar Vister Hansen <bvh@olenbetong.no>",
   "license": "MIT",
   "dependencies": {
+    "@olenbetong/appframe-data": "1.5.0",
     "body-parser": "^2.2.2",
-    "chalk": "^5.4.1",
+    "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
-    "commander": "^14.0.1",
-    "dotenv": "^17.2.3",
+    "commander": "^14.0.3",
+    "dotenv": "^17.4.2",
     "fuzzy": "^0.1.3",
-    "inquirer": "^12.9.6",
+    "inquirer": "^13.4.3",
     "inquirer-autocomplete-standalone": "^0.8.1",
     "jsdom": "29.1.1",
-    "rollup-plugin-visualizer": "^6.0.5",
-    "yaml": "^2.8.4",
-    "@olenbetong/appframe-data": "1.5.0"
+    "rollup-plugin-visualizer": "^7.0.1",
+    "yaml": "^2.9.0",
+    "@olenbetong/appframe-devtools": "0.2.0"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0",
-    "@types/node": "25.6.0",
+    "@types/node": "25.9.1",
     "typescript": "6.0.3",
-    "vite": "8.0.10"
+    "vite": "8.0.14"
   },
   "peerDependencies": {
     "vite": ">=5.0.0"