@olenbetong/appframe-vite 6.14.0 → 6.15.0

package/README.md

@@ -279,11 +279,51 @@ procedures:
 | `fields`      | `string \| string[]` | Fields to include (all if omitted)                                              |
 | `transaction` | `boolean`            | Procedures only. `false` stops the framework wrapping the call in a transaction |
 | `timeout`     | `number`             | Procedures only. Milliseconds before the call is abandoned (default `30000`)    |
+| `returnType`  | `object[] \| string` | Procedures only. The result type; see below                                     |
 
 A top-level `server` key can override the hostname (defaults to `appframe.proxy.hostname` from `package.json`).
 
 **Master/child relationships:** set both `master` and `linkFields` on the child object. The generated data object will include `masterDataObject` and `linkFields` in the `generateApiDataObject(...)` options.
 
+**Procedure result types:** the server only describes a procedure's parameters, so its result is
+typed `{ Table?: unknown[] }` unless `returnType` says otherwise. Never type the result by editing
+the generated file — every regeneration (a `resources.yaml` change seen by the dev server, a
+`git pull --rebase` that touches it, `resources generate`) writes the file from scratch. With
+`returnType` (and `types: true`) the generated file exports the type under the procedure's name,
+next to the parameters type — `procIndexDNA` gets `IndexDNAParams` and `IndexDNAResult` — so
+components import it from the generated file.
+
+`returnType` is either a list of result sets, in the order the procedure returns them (`Table`,
+`Table1`, …; `table` overrides the key), with each field's TypeScript type:
+
+```yaml
+procedures:
+  - id: procIndexDNA
+    resource: astp_Operations_IndexDNA
+    global: true
+    types: true
+    returnType:
+      - fields:
+          - name: IndexName
+            type: string
+          - name: CurrentFF
+            type: number
+      - fields:
+          - name: PageSort
+            type: number
+    output: src/features/IndexDetails/procIndexDNA.ts
+```
+
+or a TypeScript type written out as a string, for anything the list cannot express. It may refer
+to types in the app's `custom.d.ts` through the `Custom.` prefix, which adds the import:
+
+```yaml
+returnType: "Custom.IndexDNAResult"
+```
+
+`procedureReturnTypes` in `types.json`, keyed by the procedure's database name, does the same
+and is used when the entry has no `returnType`.
+
 ## `@olenbetong/appframe-vite/resources` export
 
 Shared code generation utilities for Node.js consumers:

package/lib/build.js

@@ -38,6 +38,10 @@ export const PLATFORM_EXTERNALS = [
     "highcharts-react-official",
     "mqtt",
     "temporal-polyfill",
+    // The code editor. Its stylesheet and language workers are served next to the entry, not
+    // linked by the template: only the pages that open an editor load them (synergi-react
+    // `CodeEditor` resolves them from the specifier).
+    "monaco-editor",
 ];
 /**
  * The IIFE global each platform specifier is published under (`buildConfig.entries` in the
@@ -68,6 +72,7 @@ export const PLATFORM_GLOBALS = {
     "highcharts-react-official": "SynergiPlatform.highchartsReact",
     mqtt: "SynergiPlatform.mqtt",
     "temporal-polyfill": "SynergiPlatform.temporal",
+    "monaco-editor": "SynergiPlatform.monaco",
 };
 export function usesPlatform(appframe) {
     return appframe?.build?.platform === true;
@@ -94,6 +99,7 @@ export const PLATFORM_UPSTREAM = [
     "highcharts-react-official",
     "mqtt",
     "temporal-polyfill",
+    "monaco-editor",
 ];
 /**
  * Whether the app renders `ToolbarDrawerToggle` (synergi-react) anywhere under `src/`: a plain

package/lib/cli-resources-edit.js

@@ -144,7 +144,10 @@ export async function editResource(id) {
         sortOrder = sortInput || undefined;
     }
     let relativeOutput = relative(process.cwd(), resolve(process.cwd(), output)).replace(/\\/g, "/");
+    // Start from the existing entry so settings the wizard does not ask about (returnType,
+    // master, linkFields, timeout, transaction, ...) are kept
     let updatedEntry = {
+        ...entry,
         id: newId,
         resource: entry.resource,
         output: relativeOutput,

package/lib/procedureReturnType.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/procedureReturnType.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { getProcedureDefinition } from "./resourceGenerate.js";
+import { entryToCLIOptions } from "./resourcesConfig.js";
+const definition = {
+    Parameters: [{ ParamName: "pIndexID", TypeName: "int", has_default_value: false, is_nullable: false }],
+};
+function generate(returnType) {
+    let options = entryToCLIOptions({
+        id: "procIndexDNA",
+        resource: "astp_Operations_IndexDNA",
+        output: "src/procIndexDNA.ts",
+        global: true,
+        types: true,
+        returnType,
+    }, "example.com");
+    return getProcedureDefinition("astp_Operations_IndexDNA", definition, options);
+}
+describe("procedure return types", () => {
+    it("keeps the untyped default without a returnType", () => {
+        let output = generate(undefined);
+        expect(output).not.toContain("IndexDNAResult");
+        expect(output).toContain("ProcedureAPI<IndexDNAParams, { Table?: unknown[] }>");
+    });
+    it("names a structured returnType after the procedure", () => {
+        let output = generate([
+            { fields: [{ name: "IndexName", type: "string" }] },
+            { fields: [{ name: "PageSort", type: "number" }] },
+        ]);
+        expect(output).toContain("export type IndexDNAResult = { Table: { IndexName: string }[]; Table1: { PageSort: number }[] };");
+        expect(output).toContain("ProcedureAPI<IndexDNAParams, IndexDNAResult>");
+    });
+    it("uses a string returnType as written", () => {
+        let output = generate("Custom.IndexDNAResult");
+        expect(output).toContain("export type IndexDNAResult = Custom.IndexDNAResult;");
+        expect(output).toContain('import type * as Custom from "');
+    });
+    it("does not emit a result type without types", () => {
+        let options = entryToCLIOptions({
+            id: "procIndexDNA",
+            resource: "astp_Operations_IndexDNA",
+            output: "src/procIndexDNA.ts",
+            global: true,
+            returnType: "{ Table: [] }",
+        }, "example.com");
+        let output = getProcedureDefinition("astp_Operations_IndexDNA", definition, options);
+        expect(output).not.toContain("IndexDNAResult");
+    });
+});

package/lib/resourceGenerate.js

@@ -302,7 +302,14 @@ 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 ?? "{ Table?: unknown[] }"}>` : ""}({
+    // A configured return type gets a name of its own, so components can import it and it
+    // survives every regeneration instead of being written into the output by hand.
+    let resultType = "{ Table?: unknown[] }";
+    if (options.types && options.typesJsonReturnType) {
+        resultType = `${paramTypeName.replace(/Params$/, "")}Result`;
+        output.push(`export type ${resultType} = ${options.typesJsonReturnType};\n`);
+    }
+    output.push(`export const ${procName} = new ${options.global ? "af." : ""}ProcedureAPI${options.types ? `<${paramTypeName}, ${resultType}>` : ""}({
   procedureId: "${name}",
   parameters: ${JSON.stringify(parameters, null, 2)},
   timeout: ${options.timeout ?? 30000}${options.transaction === false ? ",\n  transaction: false" : ""}

package/lib/resourcesConfig.d.ts

@@ -77,8 +77,12 @@ export type ResourceEntry = {
     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[];
+    /**
+     * Procedures only. The result type, emitted as `export type <Name>Result` next to the
+     * parameters type. Either a list of result sets with their fields, or a TypeScript type
+     * written out as a string (which may reference `Custom.*` types from `custom.d.ts`).
+     */
+    returnType?: ReturnTypeTable[] | string;
 };
 export type ResourcesConfig = {
     /** Optional server hostname override (defaults to `appframe.proxy.hostname` from package.json) */

package/lib/resourcesConfig.js

@@ -113,7 +113,11 @@ export function entryToCLIOptions(entry, hostname) {
         where: entry.where,
         fields: arrayOrStringToString(entry.fields) ?? false,
         output: resolve(process.cwd(), entry.output ?? `src/data/${entry.id}.ts`),
-        typesJsonReturnType: entry.returnType ? returnTypeToString(entry.returnType) : undefined,
+        typesJsonReturnType: typeof entry.returnType === "string"
+            ? entry.returnType
+            : entry.returnType
+                ? returnTypeToString(entry.returnType)
+                : undefined,
     };
 }
 /** Convert a `CLIOptions` back to a `ResourceEntry` for saving to YAML. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olenbetong/appframe-vite",
-  "version": "6.14.0",
+  "version": "6.15.0",
   "description": "Tools to use and deploy Vite applications to Appframe",
   "main": "./lib/index.js",
   "type": "module",
@@ -29,8 +29,8 @@
   "author": "Bjørnar Vister Hansen <bvh@olenbetong.no>",
   "license": "MIT",
   "dependencies": {
-    "@olenbetong/appframe-auth": "0.1.0",
-    "@olenbetong/appframe-data": "1.8.2",
+    "@olenbetong/appframe-auth": "^0.1.0",
+    "@olenbetong/appframe-data": "^1.8.2",
     "body-parser": "^2.3.0",
     "chalk": "6.0.1",
     "chokidar": "^5.0.0",