@reboot-dev/reboot 0.42.0 → 0.44.0

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.42.0";
+export declare const REBOOT_VERSION = "0.44.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.42.0";
+export const REBOOT_VERSION = "0.44.0";

package/zod-to-proto.js

@@ -114,7 +114,18 @@ const generate = (proto, { schema, path, name, state = false, }) => {
                         console.error(chalk.stderr.bold.red(`Unexpected literal '${literal}' for property '${key}'; only 'string' literals are currently supported`));
                         process.exit(-1);
                     }
-                    proto.write(`${literal} = ${i++};`);
+                    // According to Protobuf `enum` rules:
+                    // `enum` values use C++ scoping rules, meaning that
+                    // `enum` values are siblings of their type, not
+                    // children of it.
+                    // That means we need to prefix the `enum` values
+                    // with the `enum` type name to avoid name conflicts.
+                    // It is safe here, since we preserve the original
+                    // order of the literals and during the conversion
+                    // from Pydantic model to Protobuf and back we
+                    // operate with the indexes of the literals, not
+                    // their names.
+                    proto.write(`${typeName}_${literal} = ${i++};`);
                 }
                 proto.write(`}`);
                 proto.write(`optional ${typeName} ${field} = ${tag};`);
@@ -262,85 +273,85 @@ const generate = (proto, { schema, path, name, state = false, }) => {
         proto.write(`map <string, ${typeName}> record = 1;`);
     }
     else if (schema instanceof z.ZodArray) {
-        const element = schema.element;
-        if (element instanceof z.ZodOptional) {
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has _optional_ element type which is not supported`));
+        const item = schema.element;
+        if (item instanceof z.ZodOptional) {
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has _optional_ item type which is not supported`));
             process.exit(-1);
         }
-        else if (element instanceof z.ZodDefault) {
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has _default_ element type which is not supported`));
+        else if (item instanceof z.ZodDefault) {
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has _default_ item type which is not supported`));
             process.exit(-1);
         }
         const typeName = (() => {
             // To account for all possible "string" types in Zod, e.g.,
             // `z.uuid()`, `z.email()`, etc, we can't use `instanceof`.
-            if (element._zod.def.type === "string") {
+            if (item._zod.def.type === "string") {
                 return "string";
             }
-            else if (element instanceof z.ZodNumber) {
+            else if (item instanceof z.ZodNumber) {
                 return "double";
             }
-            else if (element instanceof z.ZodBigInt) {
+            else if (item instanceof z.ZodBigInt) {
                 return "int64";
             }
-            else if (element instanceof z.ZodBoolean) {
+            else if (item instanceof z.ZodBoolean) {
                 return "bool";
             }
-            else if (element instanceof z.ZodObject) {
-                return "Element";
+            else if (item instanceof z.ZodObject) {
+                return "Item";
             }
-            else if (element instanceof z.ZodRecord) {
-                return "Element";
+            else if (item instanceof z.ZodRecord) {
+                return "Item";
             }
-            else if (element instanceof z.ZodArray) {
-                return "Element";
+            else if (item instanceof z.ZodArray) {
+                return "Item";
             }
-            else if (element instanceof z.ZodDiscriminatedUnion) {
-                return "Element";
+            else if (item instanceof z.ZodDiscriminatedUnion) {
+                return "Item";
             }
-            else if (element instanceof z.ZodCustom) {
-                const meta = element.meta();
-                if (element instanceof z.ZodCustom && "protobuf" in meta) {
+            else if (item instanceof z.ZodCustom) {
+                const meta = item.meta();
+                if (item instanceof z.ZodCustom && "protobuf" in meta) {
                     return meta.protobuf;
                 }
             }
-            else if (iszjson(element)) {
+            else if (iszjson(item)) {
                 return "google.protobuf.Value";
             }
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has element type '${element._zod.def.type}' which is not (yet) supported`));
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has item type '${item._zod.def.type}' which is not (yet) supported`));
             process.exit(-1);
         })();
-        if (element instanceof z.ZodObject) {
+        if (item instanceof z.ZodObject) {
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
                 name: typeName,
             });
         }
-        else if (element instanceof z.ZodRecord) {
+        else if (item instanceof z.ZodRecord) {
             proto.write(`message ${typeName} {`);
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
             });
             proto.write(`}`);
         }
-        else if (element instanceof z.ZodArray) {
+        else if (item instanceof z.ZodArray) {
             proto.write(`message ${typeName} {`);
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
             });
             proto.write(`}`);
         }
-        else if (element instanceof z.ZodDiscriminatedUnion) {
+        else if (item instanceof z.ZodDiscriminatedUnion) {
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
                 name: typeName,
             });
         }
-        proto.write(`repeated ${typeName} elements = 1;`);
+        proto.write(`repeated ${typeName} items = 1;`);
     }
     else if (schema instanceof z.ZodDiscriminatedUnion) {
         assert(name !== undefined);