@globalart/zod-to-proto 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { ZodTypeAny } from "zod";
+
+//#region src/types.d.ts
+interface ZodToProtobufOptions {
+  packageName?: string;
+  rootMessageName?: string;
+  typePrefix?: string;
+  services?: ServiceDefinition[];
+  skipRootMessage?: boolean;
+}
+interface ServiceMethod {
+  name: string;
+  request: ZodTypeAny;
+  response: ZodTypeAny;
+  streaming?: 'client' | 'server' | 'bidirectional';
+}
+interface ServiceDefinition {
+  name: string;
+  methods: ServiceMethod[];
+}
+declare class UnsupportedTypeException extends Error {
+  constructor(type: string);
+}
+//#endregion
+//#region src/zod-to-protobuf.d.ts
+declare const zodToProtobuf: (schema?: ZodTypeAny, options?: ZodToProtobufOptions) => string;
+//#endregion
+export { type ServiceDefinition, type ServiceMethod, UnsupportedTypeException, type ZodToProtobufOptions, zodToProtobuf };

package/dist/index.mjs

@@ -0,0 +1,264 @@
+import * as inflection from "inflection";
+import { ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodEnum, ZodMap, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodSet, ZodString, ZodTuple, ZodType } from "zod";
+
+//#region src/types.ts
+var UnsupportedTypeException = class extends Error {
+	constructor(type) {
+		super(`Unsupported type: ${type}`);
+		this.name = "UnsupportedTypeException";
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+const getNumberTypeName = ({ value }) => {
+	return value.isInt ? "int32" : "double";
+};
+const toPascalCase = ({ value }) => {
+	return value.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+};
+const protobufFieldToType = ({ field }) => {
+	return field.types.filter(Boolean).join(" ");
+};
+
+//#endregion
+//#region src/traversers.ts
+const traverseArray = ({ key, value, messages, enums, typePrefix }) => {
+	const nestedValue = value instanceof ZodArray ? value.element : value instanceof ZodSet ? value._def.valueType : value._def.element;
+	const singularKey = inflection.singularize(key);
+	return traverseKey({
+		key: singularKey,
+		value: nestedValue,
+		messages,
+		enums,
+		isOptional: false,
+		isInArray: true,
+		typePrefix
+	}).map((field) => ({
+		...field,
+		types: ["repeated", ...field.types],
+		name: field.name.replace(singularKey, key)
+	}));
+};
+const traverseMap = ({ key, value, messages, enums, typePrefix }) => {
+	const keyType = traverseKey({
+		key: `${key}Key`,
+		value: value._def.keyType,
+		messages,
+		enums,
+		isOptional: false,
+		isInArray: true,
+		typePrefix
+	});
+	const valueType = traverseKey({
+		key: `${key}Value`,
+		value: value._def.valueType,
+		messages,
+		enums,
+		isOptional: false,
+		isInArray: true,
+		typePrefix
+	});
+	if (!keyType[0] || keyType.length !== 1) throw new UnsupportedTypeException(`${key} map key`);
+	if (!valueType[0] || valueType.length !== 1) throw new UnsupportedTypeException(`${key} map value`);
+	return [{
+		types: [`map<${protobufFieldToType({ field: keyType[0] })}, ${protobufFieldToType({ field: valueType[0] })}>`],
+		name: key
+	}];
+};
+const traverseKey = ({ key, value, messages, enums, isOptional, isInArray, typePrefix }) => {
+	if (value instanceof ZodOptional || value instanceof ZodNullable) return traverseKey({
+		key,
+		value: value.unwrap(),
+		messages,
+		enums,
+		isOptional: true,
+		isInArray,
+		typePrefix
+	});
+	if (value instanceof ZodArray || value instanceof ZodSet) return traverseArray({
+		key,
+		value,
+		messages,
+		enums,
+		typePrefix
+	});
+	if (value instanceof ZodMap) return traverseMap({
+		key,
+		value,
+		messages,
+		enums,
+		typePrefix
+	});
+	const optional = isOptional && !isInArray ? "optional" : null;
+	if (value instanceof ZodObject) {
+		let messageName = toPascalCase({ value: key });
+		if (typePrefix) messageName = `${typePrefix}${messageName}`;
+		const nestedMessageFields = traverseSchema({
+			schema: value,
+			messages,
+			enums,
+			typePrefix
+		});
+		messages.set(messageName, nestedMessageFields);
+		return [{
+			types: [optional, messageName],
+			name: key
+		}];
+	}
+	if (value instanceof ZodString) return [{
+		types: [optional, "string"],
+		name: key
+	}];
+	if (value instanceof ZodNumber) return [{
+		types: [optional, getNumberTypeName({ value })],
+		name: key
+	}];
+	if (value instanceof ZodBoolean) return [{
+		types: [optional, "bool"],
+		name: key
+	}];
+	if (value instanceof ZodEnum) {
+		const enumFields = value.options.map((option, index) => `    ${String(option)} = ${index};`).join("\n");
+		let enumName = toPascalCase({ value: key });
+		if (typePrefix) enumName = `${typePrefix}${enumName}`;
+		enums.set(enumName, [`enum ${enumName} {\n${enumFields}\n}`]);
+		return [{
+			types: [optional, enumName],
+			name: key
+		}];
+	}
+	if (value instanceof ZodDate) return [{
+		types: [optional, "string"],
+		name: key
+	}];
+	if (value instanceof ZodBigInt) return [{
+		types: [optional, "int64"],
+		name: key
+	}];
+	if (value instanceof ZodTuple) {
+		const tupleFields = value._def.items.flatMap((item, index) => {
+			return traverseKey({
+				key: `${key}_${index}`,
+				value: item,
+				messages,
+				enums,
+				isOptional: false,
+				isInArray,
+				typePrefix
+			});
+		});
+		const tupleMessageName = toPascalCase({ value: key });
+		messages.set(tupleMessageName, tupleFields.map((field, index) => `  ${field.types.join(" ")} ${field.name} = ${index + 1};`));
+		return [{
+			types: [optional, tupleMessageName],
+			name: key
+		}];
+	}
+	if (value instanceof ZodType) throw new UnsupportedTypeException(value.constructor.name);
+	throw new UnsupportedTypeException(typeof value);
+};
+const traverseSchema = ({ schema, messages, enums, typePrefix }) => {
+	if (!(schema instanceof ZodObject)) throw new UnsupportedTypeException(schema.constructor.name);
+	return Object.entries(schema.shape).flatMap(([key, value]) => {
+		return traverseKey({
+			key,
+			value,
+			messages,
+			enums,
+			isOptional: false,
+			isInArray: false,
+			typePrefix
+		});
+	}).map((field, index) => `${protobufFieldToType({ field })} ${field.name} = ${index + 1};`);
+};
+
+//#endregion
+//#region src/service-generator.ts
+const generateRequestMessageName = (methodName, typePrefix) => {
+	const messageName = toPascalCase({ value: `${methodName}Request` });
+	return typePrefix ? `${typePrefix}${messageName}` : messageName;
+};
+const generateResponseMessageName = (methodName, typePrefix) => {
+	const messageName = toPascalCase({ value: `${methodName}Response` });
+	return typePrefix ? `${typePrefix}${messageName}` : messageName;
+};
+const processServiceMethod = (method, context) => {
+	const { messages, enums, typePrefix } = context;
+	const requestName = generateRequestMessageName(method.name, typePrefix);
+	const responseName = generateResponseMessageName(method.name, typePrefix);
+	if (!messages.has(requestName)) {
+		const requestFields = traverseSchema({
+			schema: method.request,
+			messages,
+			enums,
+			typePrefix
+		});
+		messages.set(requestName, requestFields);
+	}
+	if (!messages.has(responseName)) {
+		const responseFields = traverseSchema({
+			schema: method.response,
+			messages,
+			enums,
+			typePrefix
+		});
+		messages.set(responseName, responseFields);
+	}
+	return {
+		requestName,
+		responseName
+	};
+};
+const generateServices = (services, context) => {
+	return services.map((service) => {
+		const methods = service.methods.map((method) => {
+			const { requestName, responseName } = processServiceMethod(method, context);
+			const requestStreaming = method.streaming === "client" || method.streaming === "bidirectional";
+			const responseStreaming = method.streaming === "server" || method.streaming === "bidirectional";
+			const requestType = requestStreaming ? `stream ${requestName}` : requestName;
+			const responseType = responseStreaming ? `stream ${responseName}` : responseName;
+			return `    rpc ${method.name}(${requestType}) returns (${responseType});`;
+		});
+		return `service ${service.name} {\n${methods.join("\n")}\n}`;
+	});
+};
+
+//#endregion
+//#region src/zod-to-protobuf.ts
+const zodToProtobuf = (schema, options = {}) => {
+	const { packageName = "default", rootMessageName = "Message", typePrefix = "", services = [], skipRootMessage = false } = options;
+	const messages = /* @__PURE__ */ new Map();
+	const enums = /* @__PURE__ */ new Map();
+	if (schema && !skipRootMessage) {
+		const fields = traverseSchema({
+			schema,
+			messages,
+			enums,
+			typePrefix
+		});
+		if (fields.length > 0) {
+			const rootMessageKey = `${typePrefix}${rootMessageName}`;
+			messages.set(rootMessageKey, fields);
+		}
+	}
+	const context = {
+		messages,
+		enums,
+		typePrefix: typePrefix || null
+	};
+	if (services.length > 0) generateServices(services, context);
+	return `
+syntax = "proto3";
+package ${packageName};
+
+${[
+		Array.from(enums.values()).map((enumDef) => enumDef.join("\n")),
+		Array.from(messages.entries()).map(([name, fields]) => `message ${name} {\n${fields.map((field) => `    ${field}`).join("\n")}\n}`),
+		services.length > 0 ? generateServices(services, context) : []
+	].filter((strings) => !!strings.length).map((strings) => strings.join("\n\n")).join("\n\n")}
+`.trim();
+};
+
+//#endregion
+export { UnsupportedTypeException, zodToProtobuf };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@globalart/zod-to-proto",
+  "version": "1.0.1",
+  "author": {
+    "name": "GlobalArt, Inc"
+  },
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "format": "prettier --write \"**/*.ts\"",
+    "test": "jest --runInBand --passWithNoTests",
+    "test:cov": "jest --coverage --passWithNoTests",
+    "coveralls": "yarn run test:cov --coverageReporters=text-lcov | coveralls",
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "prepublishOnly": "npm run build",
+    "publish:dev": "npm publish --access public --tag dev",
+    "publish:npm": "release-it --config ../../.release-it.json"
+  },
+  "description": "OpenID Connect strategy for GlobalArt SSO integration",
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^24.9.1",
+    "@types/passport": "^1.0.17",
+    "prettier": "^3.6.2",
+    "release-it": "19.0.6",
+    "ts-node": "^10.9.2",
+    "tsdown": "0.16.4",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "inflection": "3.0.2",
+    "zod": "4.1.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}