Parsed Action Schema

ts/packages/actionSchema/src/index.ts

@@ -8,7 +8,7 @@ export {
     ActionSchemaTypeDefinition,
     ActionSchemaEntryTypeDefinition,
     ActionSchemaGroup,
-    ActionSchemaFile,
+    ParsedActionSchema,
     ActionSchemaObject,
     ActionSchemaUnion,
 } from "./type.js";
@@ -31,11 +31,9 @@ export { getParameterType, getParameterNames } from "./utils.js";
 export * as ActionSchemaCreator from "./creator.js";
 
 export {
-    ActionSchemaFileJSON,
-    toJSONActionSchemaFile,
-    fromJSONActionSchemaFile,
-    loadParsedActionSchema,
-    saveParsedActionSchema,
+    ParsedActionSchemaJSON,
+    toJSONParsedActionSchema,
+    fromJSONParsedActionSchema,
 } from "./serialize.js";
 
 // Generic (non-action) Schema

ts/packages/actionSchema/src/parser.ts

@@ -12,9 +12,9 @@ import {
     SchemaTypeUnion,
     SchemaTypeDefinition,
     ActionSchemaTypeDefinition,
-    ActionSchemaFile,
     ActionSchemaEntryTypeDefinition,
     SchemaObjectField,
+    ParsedActionSchema,
 } from "./type.js";
 import ts from "typescript";
 import { ActionParamSpecs, SchemaConfig } from "./schemaConfig.js";
@@ -173,14 +173,13 @@ function checkActionSchema(
     return [actionNameString, actionDefinition];
 }
 
-export function createActionSchemaFile(
+export function createParsedActionSchema(
     schemaName: string,
-    sourceHash: string,
     entry: SchemaTypeDefinition,
     order: Map<string, number> | undefined,
     strict: boolean,
     schemaConfig?: SchemaConfig,
-): ActionSchemaFile {
+): ParsedActionSchema {
     if (strict && !entry.exported) {
         throw new Error(
             `Schema Error: ${schemaName}: Type '${entry.name}' must be exported`,
@@ -248,30 +247,27 @@ export function createActionSchemaFile(
     if (actionSchemas.size === 0) {
         throw new Error("No action schema found");
     }
-    const actionSchemaFile: ActionSchemaFile = {
+    const parsedActionSchema: ParsedActionSchema = {
         entry: entry as ActionSchemaEntryTypeDefinition,
-        sourceHash,
-        schemaName,
         actionSchemas,
     };
     if (schemaConfig?.actionNamespace === true) {
-        actionSchemaFile.actionNamespace = true;
+        parsedActionSchema.actionNamespace = true;
     }
     if (order) {
-        actionSchemaFile.order = order;
+        parsedActionSchema.order = order;
     }
-    return actionSchemaFile;
+    return parsedActionSchema;
 }
 
 export function parseActionSchemaSource(
     source: string,
     schemaName: string,
-    sourceHash: string,
     typeName: string,
     fileName: string = "",
     schemaConfig?: SchemaConfig,
     strict: boolean = false,
-): ActionSchemaFile {
+): ParsedActionSchema {
     debug(`Parsing ${schemaName} for ${typeName}: ${fileName}`);
     try {
         const sourceFile = ts.createSourceFile(
@@ -282,7 +278,6 @@ export function parseActionSchemaSource(
         return ActionParser.parseSourceFile(
             sourceFile,
             schemaName,
-            sourceHash,
             typeName,
             schemaConfig,
             strict,
@@ -296,7 +291,6 @@ class ActionParser {
     static parseSourceFile(
         sourceFile: ts.SourceFile,
         schemaName: string,
-        sourceHash: string,
         typeName: string,
         schemaConfig: SchemaConfig | undefined,
         strict: boolean,
@@ -306,9 +300,8 @@ class ActionParser {
         if (definition === undefined) {
             throw new Error(`Type '${typeName}' not found`);
         }
-        const result = createActionSchemaFile(
+        const result = createParsedActionSchema(
             schemaName,
-            sourceHash,
             definition,
             parser.typeOrder,
             strict,

ts/packages/actionSchema/src/serialize.ts

@@ -1,26 +1,20 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { createActionSchemaFile } from "./parser.js";
+import { createParsedActionSchema } from "./parser.js";
 import {
-    ActionSchemaFile,
     ParsedActionSchema,
     SchemaType,
     SchemaTypeDefinition,
 } from "./type.js";
 
-export type ParsedActionSchemaGroupJSON = {
+export type ParsedActionSchemaJSON = {
     entry: string;
     types: Record<string, SchemaTypeDefinition>;
     actionNamespace?: boolean; // default to false
     order?: Record<string, number>;
 };
 
-export type ActionSchemaFileJSON = {
-    schemaName: string;
-    sourceHash: string;
-} & ParsedActionSchemaGroupJSON;
-
 function collectTypes(
     definitions: Record<string, SchemaTypeDefinition>,
     type: SchemaType,
@@ -60,15 +54,22 @@ function collectTypes(
     }
 }
 
-function toJSONActionSchemaGroup(
+/**
+ * Convert a ParsedActionSchema to a JSON-able object
+ * Data in the original ParsedActionSchema will not be modified.
+ *
+ * @param parsedActionSchema ParsedActionSchema to convert
+ * @returns
+ */
+export function toJSONParsedActionSchema(
     parsedActionSchema: ParsedActionSchema,
-): ParsedActionSchemaGroupJSON {
+): ParsedActionSchemaJSON {
     const definitions: Record<string, SchemaTypeDefinition> = {};
     // clone it so we can modified it.
     const entry = structuredClone(parsedActionSchema.entry);
     definitions[entry.name] = entry;
     collectTypes(definitions, entry.type);
-    const result: ParsedActionSchemaGroupJSON = {
+    const result: ParsedActionSchemaJSON = {
         entry: entry.name,
         types: definitions,
     };
@@ -81,24 +82,6 @@ function toJSONActionSchemaGroup(
     return result;
 }
 
-/**
- * Convert a ActionSchemaFile to a JSON-able object
- * Data in the original ActionSchemaFile will not be modified.
- *
- * @param actionSchemaFile ActionSchemaFile to convert
- * @returns
- */
-export function toJSONActionSchemaFile(
-    actionSchemaFile: ActionSchemaFile,
-): ActionSchemaFileJSON {
-    const result: ActionSchemaFileJSON = {
-        schemaName: actionSchemaFile.schemaName,
-        sourceHash: actionSchemaFile.sourceHash,
-        ...toJSONActionSchemaGroup(actionSchemaFile),
-    };
-    return result;
-}
-
 function resolveTypes(
     definitions: Record<string, SchemaTypeDefinition>,
     type: SchemaType,
@@ -133,16 +116,18 @@ function resolveTypes(
 }
 
 /**
- * Convert a ActionSchemaFileJSON back to a ActionSchemaFile
+ * Convert a ParsedActionSchemaJSON back to a ParsedActionSchema
  * Data in the JSON will be modified.
  * Clone the data before passing into this function if you want to keep the original.
  *
  * @param json JSON data to convert
+ * @param schemaName Name of the schema (for error messages)
  * @returns
  */
-export function fromJSONActionSchemaFile(
-    json: ActionSchemaFileJSON,
-): ActionSchemaFile {
+export function fromJSONParsedActionSchema(
+    json: ParsedActionSchemaJSON,
+    schemaName: string,
+): ParsedActionSchema {
     for (const type of Object.values(json.types)) {
         resolveTypes(json.types, type.type);
     }
@@ -154,38 +139,11 @@ export function fromJSONActionSchemaFile(
               actionNamespace: json.actionNamespace,
           }
         : undefined;
-    return createActionSchemaFile(
-        json.schemaName,
-        json.sourceHash,
+    return createParsedActionSchema(
+        schemaName,
         entry,
         order,
         true,
         schemaConfig,
     );
 }
-
-export function loadParsedActionSchema(
-    schemaName: string,
-    schemaType: string,
-    sourceHash: string,
-    source: string,
-): ActionSchemaFile {
-    const json = JSON.parse(source);
-    // TODO: validate the json
-    json.schemaName = schemaName;
-    json.sourceHash = sourceHash;
-    const actionSchemaFile = fromJSONActionSchemaFile(json);
-    if (actionSchemaFile.entry.name !== schemaType) {
-        throw new Error(
-            `Schema type mismatch: ${actionSchemaFile.entry.name} != ${schemaType}`,
-        );
-    }
-    return actionSchemaFile;
-}
-
-export function saveParsedActionSchema(
-    parsedActionSchema: ParsedActionSchema,
-): string {
-    const json = toJSONActionSchemaGroup(parsedActionSchema);
-    return JSON.stringify(json);
-}

ts/packages/actionSchema/src/type.ts

@@ -149,11 +149,3 @@ export type ParsedActionSchema = ActionSchemaGroup & {
     // separate the cache by action name
     actionNamespace?: boolean; // default to false
 };
-
-export type ActionSchemaFile = ParsedActionSchema & {
-    // Schema name
-    schemaName: string;
-
-    // original file source hash
-    sourceHash: string;
-};

ts/packages/actionSchema/test/parse.spec.ts

@@ -9,7 +9,6 @@ describe("Action Schema Strict Checks", () => {
             parseActionSchemaSource(
                 `type SomeAction = { actionName: "someAction" }`,
                 "test",
-                "",
                 "SomeAction",
                 "",
                 undefined,
@@ -24,7 +23,6 @@ describe("Action Schema Strict Checks", () => {
             parseActionSchemaSource(
                 `// comments\nexport type AllActions = SomeAction;\ntype SomeAction = { actionName: "someAction" }`,
                 "test",
-                "",
                 "AllActions",
                 "",
                 undefined,
@@ -39,7 +37,6 @@ describe("Action Schema Strict Checks", () => {
             parseActionSchemaSource(
                 `export type AllActions = SomeAction | SomeAction2;\ntype SomeAction = { actionName: "someAction" }\ntype SomeAction2 = { actionName: "someAction" }`,
                 "test",
-                "",
                 "AllActions",
                 "",
                 undefined,
@@ -54,7 +51,6 @@ describe("Action Schema Strict Checks", () => {
             parseActionSchemaSource(
                 `export type AllActions = SomeAction | { actionName: "someAction2" };\ntype SomeAction = { actionName: "someAction" }`,
                 "test",
-                "",
                 "AllActions",
                 "",
                 undefined,

ts/packages/actionSchema/test/regen.spec.ts

@@ -6,8 +6,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { parseActionSchemaSource } from "../src/parser.js";
 import {
-    toJSONActionSchemaFile,
-    fromJSONActionSchemaFile,
+    toJSONParsedActionSchema,
+    fromJSONParsedActionSchema,
 } from "../src/serialize.js";
 import { fileURLToPath } from "node:url";
 import { generateActionSchema } from "../src/generator.js";
@@ -119,7 +119,6 @@ describe("Action Schema Regeneration", () => {
             const actionSchemaFile = parseActionSchemaSource(
                 source,
                 schemaName,
-                "testHash", // Don't care about source hash in tests
                 typeName,
                 fileName,
                 schemaConfig,
@@ -138,7 +137,6 @@ describe("Action Schema Regeneration", () => {
             const actionSchemaFile = parseActionSchemaSource(
                 source,
                 schemaName,
-                "testHash", // Don't care about source hash in tests
                 typeName,
                 fileName,
             );
@@ -147,7 +145,6 @@ describe("Action Schema Regeneration", () => {
             const roundtrip = parseActionSchemaSource(
                 regenerated,
                 schemaName,
-                "testHash", // Don't care about source hash in tests
                 typeName,
             );
             const schema2 = await generateActionSchema(roundtrip);
@@ -163,22 +160,23 @@ describe("Action Schema Serialization", () => {
             const actionSchemaFile = parseActionSchemaSource(
                 source,
                 schemaName,
-                "testHash", // Don't care about source hash in tests
                 typeName,
                 fileName,
             );
-            const serialized = toJSONActionSchemaFile(actionSchemaFile);
-            const deserialized = fromJSONActionSchemaFile(
+            const serialized = toJSONParsedActionSchema(actionSchemaFile);
+            const deserialized = fromJSONParsedActionSchema(
                 structuredClone(serialized),
+                schemaName,
             );
 
             expect(deserialized).toEqual(actionSchemaFile);
 
-            const serialized2 = toJSONActionSchemaFile(actionSchemaFile);
+            const serialized2 = toJSONParsedActionSchema(actionSchemaFile);
             expect(serialized2).toEqual(serialized);
 
-            const deserialized2 = fromJSONActionSchemaFile(
+            const deserialized2 = fromJSONParsedActionSchema(
                 structuredClone(serialized),
+                schemaName,
             );
             expect(deserialized2).toEqual(deserialized);
         },

ts/packages/actionSchemaCompiler/src/index.ts

@@ -5,7 +5,7 @@ import { Command, Flags } from "@oclif/core";
 import {
     parseActionSchemaSource,
     SchemaConfig,
-    saveParsedActionSchema,
+    toJSONParsedActionSchema,
 } from "action-schema";
 import path from "node:path";
 import fs from "node:fs";
@@ -51,7 +51,6 @@ export default class Compile extends Command {
         const actionSchemaFile = parseActionSchemaSource(
             fs.readFileSync(flags.input, "utf-8"),
             name,
-            "",
             flags.schemaType,
             flags.input,
             getSchemaConfig(flags.input),
@@ -67,7 +66,7 @@ export default class Compile extends Command {
         }
         fs.writeFileSync(
             flags.output,
-            saveParsedActionSchema(actionSchemaFile),
+            JSON.stringify(toJSONParsedActionSchema(actionSchemaFile)),
         );
         console.log(`Parsed action schema written: ${flags.output}`);
     }