@foxglove/schemas 0.1.2

package/schemas/typescript/Vector2.ts

@@ -0,0 +1,10 @@
+// Generated from Vector2 by @foxglove/schemas
+
+/** A vector in 2D space that represents a direction only */
+export type Vector2 = {
+  /** x coordinate length */
+  x: number;
+
+  /** y coordinate length */
+  y: number;
+};

package/schemas/typescript/Vector3.ts

@@ -0,0 +1,13 @@
+// Generated from Vector3 by @foxglove/schemas
+
+/** A vector in 3D space that represents a direction only */
+export type Vector3 = {
+  /** x coordinate length */
+  x: number;
+
+  /** y coordinate length */
+  y: number;
+
+  /** z coordinate length */
+  z: number;
+};

package/schemas/typescript/index.ts

@@ -0,0 +1,28 @@
+export * from "./CameraCalibration";
+export * from "./CircleAnnotation";
+export * from "./Color";
+export * from "./CompressedImage";
+export * from "./FrameTransform";
+export * from "./GeoJSON";
+export * from "./Grid";
+export * from "./ImageAnnotations";
+export * from "./LaserScan";
+export * from "./LocationFix";
+export * from "./Log";
+export * from "./LogLevel";
+export * from "./NumericType";
+export * from "./PackedElementField";
+export * from "./Point2";
+export * from "./Point3";
+export * from "./PointCloud";
+export * from "./PointsAnnotation";
+export * from "./PointsAnnotationType";
+export * from "./Pose";
+export * from "./PoseInFrame";
+export * from "./PosesInFrame";
+export * from "./PositionCovarianceType";
+export * from "./Quaternion";
+export * from "./RawImage";
+export * from "./Transform";
+export * from "./Vector2";
+export * from "./Vector3";

package/scripts/updateGeneratedFiles.ts

@@ -0,0 +1,103 @@
+import { program } from "commander";
+import fs from "fs/promises";
+import path from "path";
+import rimraf from "rimraf";
+import { promisify } from "util";
+
+import { generateRosMsg, generateRosMsgDefinition } from "../src";
+import { generateJsonSchema } from "../src/generateJsonSchema";
+import { generateProto } from "../src/generateProto";
+import { generateTypeScript, DURATION_TS, TIME_TS } from "../src/generateTypeScript";
+import { foxgloveEnumSchemas, foxgloveMessageSchemas } from "../src/schemas";
+
+async function logProgress(message: string, body: () => Promise<void>) {
+  process.stderr.write(`${message}... `);
+  await body();
+  process.stderr.write("done\n");
+}
+
+async function main({ outDir }: { outDir: string }) {
+  await logProgress("Removing any existing output directory", async () => {
+    await promisify(rimraf)(outDir);
+  });
+
+  await logProgress("Generating JSONSchema definitions", async () => {
+    await fs.mkdir(path.join(outDir, "jsonschema"), { recursive: true });
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      await fs.writeFile(
+        path.join(outDir, "jsonschema", `${schema.name}.json`),
+        JSON.stringify(generateJsonSchema(schema), undefined, 2) + "\n",
+      );
+    }
+  });
+
+  await logProgress("Generating ROS 1 msg files", async () => {
+    await fs.mkdir(path.join(outDir, "ros1"), { recursive: true });
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      if (schema.rosEquivalent != undefined) {
+        continue;
+      }
+      await fs.writeFile(
+        path.join(outDir, "ros1", `${schema.name}.msg`),
+        generateRosMsg(generateRosMsgDefinition(schema, { rosVersion: 1 })),
+      );
+    }
+  });
+
+  await logProgress("Generating ROS 2 msg files", async () => {
+    await fs.mkdir(path.join(outDir, "ros2"), { recursive: true });
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      if (schema.rosEquivalent != undefined) {
+        continue;
+      }
+      await fs.writeFile(
+        path.join(outDir, "ros2", `${schema.name}.msg`),
+        generateRosMsg(generateRosMsgDefinition(schema, { rosVersion: 2 })),
+      );
+    }
+  });
+
+  await logProgress("Generating Protobuf definitions", async () => {
+    await fs.mkdir(path.join(outDir, "proto", "foxglove"), { recursive: true });
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      const enums = Object.values(foxgloveEnumSchemas).filter(
+        (enumSchema) => enumSchema.protobufParentMessageName === schema.name,
+      );
+      await fs.writeFile(
+        path.join(outDir, "proto", "foxglove", `${schema.name}.proto`),
+        generateProto(schema, enums),
+      );
+    }
+  });
+
+  await logProgress("Generating TypeScript definitions", async () => {
+    await fs.mkdir(path.join(outDir, "typescript"), { recursive: true });
+    await fs.writeFile(path.join(outDir, "typescript", "Time.ts"), TIME_TS);
+    await fs.writeFile(path.join(outDir, "typescript", "Duration.ts"), DURATION_TS);
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      await fs.writeFile(
+        path.join(outDir, "typescript", `${schema.name}.ts`),
+        generateTypeScript(schema),
+      );
+    }
+    for (const schema of Object.values(foxgloveEnumSchemas)) {
+      await fs.writeFile(
+        path.join(outDir, "typescript", `${schema.name}.ts`),
+        generateTypeScript(schema),
+      );
+    }
+    const allSchemaNames = [
+      ...Object.values(foxgloveMessageSchemas),
+      ...Object.values(foxgloveEnumSchemas),
+    ].sort((a, b) => a.name.localeCompare(b.name));
+    let indexTS = "";
+    for (const schema of allSchemaNames) {
+      indexTS += `export * from "./${schema.name}";\n`;
+    }
+    await fs.writeFile(path.join(outDir, "typescript", `index.ts`), indexTS);
+  });
+}
+
+program.requiredOption("-o, --out-dir <dir>", "output directory").action(main);
+
+program.parseAsync().catch(console.error);

package/src/generateJsonSchema.test.ts

@@ -0,0 +1,314 @@
+import Ajv from "ajv";
+
+import { generateJsonSchema } from "./generateJsonSchema";
+import { foxgloveMessageSchemas } from "./schemas";
+import { exampleMessage } from "./testFixtures";
+
+describe("generateJsonSchema", () => {
+  it("generates expected JSON Schema", () => {
+    expect(generateJsonSchema(exampleMessage)).toMatchInlineSnapshot(`
+      Object {
+        "$comment": "Generated from ExampleMessage by @foxglove/schemas",
+        "description": "An example type",
+        "properties": Object {
+          "field_boolean": Object {
+            "description": "boolean field",
+            "type": "boolean",
+          },
+          "field_boolean_array": Object {
+            "description": "boolean array field",
+            "items": Object {
+              "type": "boolean",
+            },
+            "type": "array",
+          },
+          "field_boolean_fixed_array": Object {
+            "description": "boolean fixed-length array field",
+            "items": Object {
+              "type": "boolean",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_bytes": Object {
+            "contentEncoding": "base64",
+            "description": "bytes field",
+            "type": "string",
+          },
+          "field_bytes_array": Object {
+            "description": "bytes array field",
+            "items": Object {
+              "contentEncoding": "base64",
+              "type": "string",
+            },
+            "type": "array",
+          },
+          "field_bytes_fixed_array": Object {
+            "description": "bytes fixed-length array field",
+            "items": Object {
+              "contentEncoding": "base64",
+              "type": "string",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_duration": Object {
+            "description": "duration field",
+            "properties": Object {
+              "nsec": Object {
+                "maximum": 999999999,
+                "minimum": 0,
+                "type": "integer",
+              },
+              "sec": Object {
+                "type": "integer",
+              },
+            },
+            "title": "duration",
+            "type": "object",
+          },
+          "field_duration_array": Object {
+            "description": "duration array field",
+            "items": Object {
+              "properties": Object {
+                "nsec": Object {
+                  "maximum": 999999999,
+                  "minimum": 0,
+                  "type": "integer",
+                },
+                "sec": Object {
+                  "type": "integer",
+                },
+              },
+              "title": "duration",
+              "type": "object",
+            },
+            "type": "array",
+          },
+          "field_duration_fixed_array": Object {
+            "description": "duration fixed-length array field",
+            "items": Object {
+              "properties": Object {
+                "nsec": Object {
+                  "maximum": 999999999,
+                  "minimum": 0,
+                  "type": "integer",
+                },
+                "sec": Object {
+                  "type": "integer",
+                },
+              },
+              "title": "duration",
+              "type": "object",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_enum": Object {
+            "description": "An enum field",
+            "oneOf": Array [
+              Object {
+                "const": 1,
+                "description": "Value A",
+                "title": "A",
+              },
+              Object {
+                "const": 2,
+                "description": "Value B",
+                "title": "B",
+              },
+            ],
+            "title": "ExampleEnum: An example enum",
+          },
+          "field_enum_array": Object {
+            "description": "An enum array field",
+            "items": Object {
+              "description": "An enum array field",
+              "oneOf": Array [
+                Object {
+                  "const": 1,
+                  "description": "Value A",
+                  "title": "A",
+                },
+                Object {
+                  "const": 2,
+                  "description": "Value B",
+                  "title": "B",
+                },
+              ],
+              "title": "ExampleEnum: An example enum",
+            },
+            "type": "array",
+          },
+          "field_float64": Object {
+            "description": "float64 field",
+            "type": "number",
+          },
+          "field_float64_array": Object {
+            "description": "float64 array field",
+            "items": Object {
+              "type": "number",
+            },
+            "type": "array",
+          },
+          "field_float64_fixed_array": Object {
+            "description": "float64 fixed-length array field",
+            "items": Object {
+              "type": "number",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_nested": Object {
+            "$comment": "Generated from NestedMessage by @foxglove/schemas",
+            "description": "A nested field",
+            "properties": Object {
+              "field_enum": Object {
+                "description": "An enum field",
+                "minimum": 0,
+                "type": "integer",
+              },
+            },
+            "title": "NestedMessage",
+            "type": "object",
+          },
+          "field_nested_array": Object {
+            "description": "A nested array field
+      With
+      a
+      very
+      long
+      description",
+            "items": Object {
+              "$comment": "Generated from NestedMessage by @foxglove/schemas",
+              "description": "An example nested message",
+              "properties": Object {
+                "field_enum": Object {
+                  "description": "An enum field",
+                  "minimum": 0,
+                  "type": "integer",
+                },
+              },
+              "title": "NestedMessage",
+              "type": "object",
+            },
+            "type": "array",
+          },
+          "field_string": Object {
+            "description": "string field",
+            "type": "string",
+          },
+          "field_string_array": Object {
+            "description": "string array field",
+            "items": Object {
+              "type": "string",
+            },
+            "type": "array",
+          },
+          "field_string_fixed_array": Object {
+            "description": "string fixed-length array field",
+            "items": Object {
+              "type": "string",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_time": Object {
+            "description": "time field",
+            "properties": Object {
+              "nsec": Object {
+                "maximum": 999999999,
+                "minimum": 0,
+                "type": "integer",
+              },
+              "sec": Object {
+                "minimum": 0,
+                "type": "integer",
+              },
+            },
+            "title": "time",
+            "type": "object",
+          },
+          "field_time_array": Object {
+            "description": "time array field",
+            "items": Object {
+              "properties": Object {
+                "nsec": Object {
+                  "maximum": 999999999,
+                  "minimum": 0,
+                  "type": "integer",
+                },
+                "sec": Object {
+                  "minimum": 0,
+                  "type": "integer",
+                },
+              },
+              "title": "time",
+              "type": "object",
+            },
+            "type": "array",
+          },
+          "field_time_fixed_array": Object {
+            "description": "time fixed-length array field",
+            "items": Object {
+              "properties": Object {
+                "nsec": Object {
+                  "maximum": 999999999,
+                  "minimum": 0,
+                  "type": "integer",
+                },
+                "sec": Object {
+                  "minimum": 0,
+                  "type": "integer",
+                },
+              },
+              "title": "time",
+              "type": "object",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+          "field_uint32": Object {
+            "description": "uint32 field",
+            "minimum": 0,
+            "type": "integer",
+          },
+          "field_uint32_array": Object {
+            "description": "uint32 array field",
+            "items": Object {
+              "minimum": 0,
+              "type": "integer",
+            },
+            "type": "array",
+          },
+          "field_uint32_fixed_array": Object {
+            "description": "uint32 fixed-length array field",
+            "items": Object {
+              "minimum": 0,
+              "type": "integer",
+            },
+            "maxItems": 3,
+            "minItems": 3,
+            "type": "array",
+          },
+        },
+        "title": "ExampleMessage",
+        "type": "object",
+      }
+    `);
+  });
+
+  it.each(Object.values(foxgloveMessageSchemas))(
+    "generates parseable JSON Schema for $name",
+    (schema) => {
+      const ajv = new Ajv();
+      expect(() => ajv.compile(generateJsonSchema(schema))).not.toThrow();
+    },
+  );
+});

package/src/generateJsonSchema.ts

@@ -0,0 +1,82 @@
+import { FoxgloveMessageSchema, FoxglovePrimitive } from "./types";
+
+function primitiveToJsonSchema(type: Exclude<FoxglovePrimitive, "bytes">) {
+  switch (type) {
+    case "string":
+      return { type: "string" };
+    case "boolean":
+      return { type: "boolean" };
+    case "float64":
+      return { type: "number" };
+    case "uint32":
+      return { type: "integer", minimum: 0 };
+    case "time":
+      return {
+        type: "object",
+        title: "time",
+        properties: {
+          sec: { type: "integer", minimum: 0 },
+          nsec: { type: "integer", minimum: 0, maximum: 999_999_999 },
+        },
+      };
+    case "duration":
+      return {
+        type: "object",
+        title: "duration",
+        properties: {
+          sec: { type: "integer" },
+          nsec: { type: "integer", minimum: 0, maximum: 999_999_999 },
+        },
+      };
+  }
+}
+
+export function generateJsonSchema(schema: FoxgloveMessageSchema): Record<string, unknown> {
+  const properties: Record<string, unknown> = {};
+  for (const field of schema.fields) {
+    let fieldType: Record<string, unknown>;
+    switch (field.type.type) {
+      case "primitive":
+        if (field.type.name === "bytes") {
+          fieldType = { type: "string", contentEncoding: "base64" };
+        } else {
+          fieldType = primitiveToJsonSchema(field.type.name);
+        }
+        break;
+      case "nested":
+        fieldType = generateJsonSchema(field.type.schema);
+        break;
+      case "enum":
+        fieldType = {
+          title: `${field.type.enum.name}: ${field.type.enum.description}`,
+          description: field.description,
+          oneOf: field.type.enum.values.map(({ name, value, description }) => ({
+            title: name,
+            const: value,
+            description,
+          })),
+        };
+        break;
+    }
+    if (typeof field.array === "number") {
+      fieldType = {
+        type: "array",
+        items: fieldType,
+        minItems: field.array,
+        maxItems: field.array,
+      };
+    } else if (field.array === true) {
+      fieldType = { type: "array", items: fieldType };
+    }
+    fieldType.description = field.description;
+    properties[field.name] = fieldType;
+  }
+
+  return {
+    $comment: `Generated from ${schema.name} by @foxglove/schemas`,
+    title: schema.name,
+    description: schema.description,
+    type: "object",
+    properties,
+  };
+}

package/src/generateProto.test.ts

@@ -0,0 +1,126 @@
+import protobufjs from "protobufjs";
+
+import { generateProto } from "./generateProto";
+import { foxgloveEnumSchemas, foxgloveMessageSchemas } from "./schemas";
+import { exampleEnum, exampleMessage } from "./testFixtures";
+
+describe("generateProto", () => {
+  it("generates .proto files", () => {
+    expect(generateProto(exampleMessage, [exampleEnum])).toMatchInlineSnapshot(`
+      "// Generated from ExampleMessage by @foxglove/schemas
+
+      syntax = \\"proto3\\";
+
+      import \\"foxglove/NestedMessage.proto\\";
+      import \\"google/protobuf/duration.proto\\";
+      import \\"google/protobuf/timestamp.proto\\";
+
+      package foxglove;
+
+      // An example type
+      message ExampleMessage {
+        // An example enum
+        enum ExampleProtoEnum {
+          // Value A
+          A = 1;
+
+          // Value B
+          B = 2;
+        }
+        // duration field
+        google.protobuf.Duration field_duration = 1;
+
+        // time field
+        google.protobuf.Timestamp field_time = 2;
+
+        // boolean field
+        bool field_boolean = 3;
+
+        // bytes field
+        bytes field_bytes = 4;
+
+        // float64 field
+        double field_float64 = 5;
+
+        // uint32 field
+        fixed32 field_uint32 = 6;
+
+        // string field
+        string field_string = 7;
+
+        // duration array field
+        repeated google.protobuf.Duration field_duration_array = 8;
+
+        // time array field
+        repeated google.protobuf.Timestamp field_time_array = 9;
+
+        // boolean array field
+        repeated bool field_boolean_array = 10;
+
+        // bytes array field
+        repeated bytes field_bytes_array = 11;
+
+        // float64 array field
+        repeated double field_float64_array = 12;
+
+        // uint32 array field
+        repeated fixed32 field_uint32_array = 13;
+
+        // string array field
+        repeated string field_string_array = 14;
+
+        // duration fixed-length array field
+        repeated google.protobuf.Duration field_duration_fixed_array = 15; // length 3
+
+        // time fixed-length array field
+        repeated google.protobuf.Timestamp field_time_fixed_array = 16; // length 3
+
+        // boolean fixed-length array field
+        repeated bool field_boolean_fixed_array = 17; // length 3
+
+        // bytes fixed-length array field
+        repeated bytes field_bytes_fixed_array = 18; // length 3
+
+        // float64 fixed-length array field
+        repeated double field_float64_fixed_array = 19; // length 3
+
+        // uint32 fixed-length array field
+        repeated fixed32 field_uint32_fixed_array = 20; // length 3
+
+        // string fixed-length array field
+        repeated string field_string_fixed_array = 21; // length 3
+
+        // An enum field
+        ExampleProtoEnum field_enum = 22;
+
+        // An enum array field
+        repeated ExampleProtoEnum field_enum_array = 23;
+
+        // A nested field
+        foxglove.NestedMessage field_nested = 24;
+
+        // A nested array field
+        // With
+        // a
+        // very
+        // long
+        // description
+        repeated foxglove.NestedMessage field_nested_array = 25;
+      }
+      "
+    `);
+  });
+
+  it("generates parseable .proto files", () => {
+    const root = new protobufjs.Root();
+    root.addJSON(protobufjs.common.get("google/protobuf/timestamp.proto")!.nested!);
+    root.addJSON(protobufjs.common.get("google/protobuf/duration.proto")!.nested!);
+    for (const schema of Object.values(foxgloveMessageSchemas)) {
+      const enums = Object.values(foxgloveEnumSchemas).filter(
+        (enumSchema) => enumSchema.protobufParentMessageName === schema.name,
+      );
+      root.add(protobufjs.parse(generateProto(schema, enums)).root);
+    }
+    expect(() => root.resolveAll()).not.toThrow();
+  });
+});