Timothy J. Aveni
722 lines
27 KiB
JavaScript
722 lines
27 KiB
JavaScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import protobuf from "protobufjs";
|
|
const CLASS_OPTION = "(camino.class)";
|
|
const INTERFACE_OPTION = "(camino.interface)";
|
|
const IMPLEMENTS_OPTION = "(camino.implements)";
|
|
const CONSTRUCTOR_OPTION = "(camino.constructor)";
|
|
const METHOD_OPTION = "(camino.method)";
|
|
const MIGRATION_OPTION = "(camino.migration)";
|
|
const CONFLICT_OPTION = "(camino.conflict)";
|
|
const EDGE_OPTION = "(camino.edge)";
|
|
const FIELD_STORAGE_OPTION = "(camino.field_storage)";
|
|
const FIELD_OPS_OPTION = "(camino.field_ops)";
|
|
const INTERFACE_FIELD_OPTION = "(camino.interface_field)";
|
|
const DISPLAY_LABEL_OPTION = "(camino.display_label)";
|
|
const IMPL_OPTION = "(camino.impl)";
|
|
const SCHEMA_NAMESPACE_OPTION = "(camino.schema_namespace)";
|
|
const SCHEMA_VERSION_OPTION = "(camino.schema_version)";
|
|
const enumName = (value) => String(value)
|
|
.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
|
|
.replace(/-/g, "_")
|
|
.toUpperCase();
|
|
const lowerEnumName = (value) => enumName(value).toLowerCase();
|
|
const getOption = (options, name) => {
|
|
if (!options) {
|
|
return undefined;
|
|
}
|
|
if (Object.hasOwn(options, name)) {
|
|
return options[name];
|
|
}
|
|
const bareName = name.replace(/^\((.*)\)$/, "$1");
|
|
if (Object.hasOwn(options, bareName)) {
|
|
return options[bareName];
|
|
}
|
|
return undefined;
|
|
};
|
|
const getParsedOptions = (reflection) => {
|
|
const parsedOptions = reflection
|
|
.parsedOptions;
|
|
return Array.isArray(parsedOptions)
|
|
? parsedOptions.filter((option) => Boolean(option) && typeof option === "object" && !Array.isArray(option))
|
|
: [];
|
|
};
|
|
const getReflectionOptions = (reflection, name) => {
|
|
const parsedValues = getParsedOptions(reflection).flatMap((option) => {
|
|
const value = getOption(option, name);
|
|
return value === undefined ? [] : [value];
|
|
});
|
|
if (parsedValues.length > 0) {
|
|
return parsedValues;
|
|
}
|
|
const value = getOption(reflection.options, name);
|
|
return value === undefined ? [] : [value];
|
|
};
|
|
const getReflectionOption = (reflection, name) => getReflectionOptions(reflection, name)[0];
|
|
const asObject = (value) => value && typeof value === "object" && !Array.isArray(value)
|
|
? value
|
|
: undefined;
|
|
const asArray = (value) => Array.isArray(value) ? value : value === undefined ? [] : [value];
|
|
const readString = (object, key) => {
|
|
const value = object?.[key];
|
|
return typeof value === "string" ? value : undefined;
|
|
};
|
|
const readNumber = (object, key) => {
|
|
const value = object?.[key];
|
|
return typeof value === "number" && Number.isFinite(value)
|
|
? value
|
|
: undefined;
|
|
};
|
|
const readBoolean = (object, key) => {
|
|
const value = object?.[key];
|
|
return typeof value === "boolean" ? value : undefined;
|
|
};
|
|
const symbolRefFromOption = (value, fallback) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return fallback;
|
|
}
|
|
return {
|
|
namespace: readString(object, "namespace") ?? fallback.namespace,
|
|
name: readString(object, "name") ?? fallback.name,
|
|
version: readString(object, "version") ?? fallback.version,
|
|
...(readString(object, "hash")
|
|
? { hash: readString(object, "hash") }
|
|
: {}),
|
|
};
|
|
};
|
|
const typeRefFromOption = (value, fallbackVersion) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return undefined;
|
|
}
|
|
const symbol = asObject(object.symbol)
|
|
? symbolRefFromOption(object.symbol, {
|
|
namespace: "",
|
|
name: "",
|
|
version: fallbackVersion,
|
|
})
|
|
: undefined;
|
|
const protoType = readString(object, "proto_type")?.replace(/^\./, "");
|
|
const symbolProtoType = symbol?.namespace && symbol.name ? `${symbol.namespace}.${symbol.name}` : "";
|
|
const resolvedProtoType = protoType ?? symbolProtoType;
|
|
if (!resolvedProtoType) {
|
|
return undefined;
|
|
}
|
|
return {
|
|
protoType: resolvedProtoType,
|
|
...(symbol?.namespace && symbol.name ? { symbol } : {}),
|
|
};
|
|
};
|
|
const interfaceFieldContractFromOption = (value, schemaVersion) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return undefined;
|
|
}
|
|
const type = typeRefFromOption(object.type, schemaVersion);
|
|
const refTargetTypeParam = readString(object, "ref_target_type_param");
|
|
const edgeCardinality = object.edge_cardinality === undefined
|
|
? undefined
|
|
: cardinalityFromOption(object.edge_cardinality);
|
|
return {
|
|
required: readBoolean(object, "required") ?? false,
|
|
readable: readBoolean(object, "readable") ?? false,
|
|
writable: readBoolean(object, "writable") ?? false,
|
|
watchable: readBoolean(object, "watchable") ?? false,
|
|
...(readString(object, "type_param")
|
|
? { typeParam: readString(object, "type_param") }
|
|
: {}),
|
|
...(type ? { type } : {}),
|
|
...(refTargetTypeParam ? { refTargetTypeParam } : {}),
|
|
...(edgeCardinality ? { edgeCardinality } : {}),
|
|
};
|
|
};
|
|
const functionRefFromOption = (value) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
throw new Error("Expected function ref option object");
|
|
}
|
|
const packageNamespace = readString(object, "package_namespace");
|
|
const packageName = readString(object, "package_name");
|
|
const symbol = readString(object, "symbol");
|
|
if (!packageNamespace || !packageName || !symbol) {
|
|
throw new Error("Function ref requires package_namespace, package_name, and symbol");
|
|
}
|
|
return {
|
|
packageNamespace,
|
|
packageName,
|
|
symbol,
|
|
...(readString(object, "operation")
|
|
? { operation: readString(object, "operation") }
|
|
: {}),
|
|
...(readString(object, "version_ref")
|
|
? { versionRef: readString(object, "version_ref") }
|
|
: {}),
|
|
};
|
|
};
|
|
const conflictFromOption = (value) => {
|
|
const normalized = enumName(value);
|
|
if (!value || normalized === "CONFLICT_STRATEGY_UNSPECIFIED") {
|
|
return "preserve_conflicts";
|
|
}
|
|
if (normalized === "REPLACE") {
|
|
return "replace";
|
|
}
|
|
if (normalized === "PRESERVE_CONFLICTS") {
|
|
return "preserve_conflicts";
|
|
}
|
|
if (normalized === "CRDT") {
|
|
return "crdt";
|
|
}
|
|
throw new Error(`Unknown Camino conflict strategy: ${String(value)}`);
|
|
};
|
|
const cardinalityFromOption = (value) => {
|
|
const normalized = lowerEnumName(value);
|
|
if (!value || normalized === "cardinality_unspecified") {
|
|
return "many";
|
|
}
|
|
if (normalized === "optional_one" ||
|
|
normalized === "exactly_one" ||
|
|
normalized === "many" ||
|
|
normalized === "many_unique" ||
|
|
normalized === "many_ordered" ||
|
|
normalized === "many_unique_ordered") {
|
|
return normalized;
|
|
}
|
|
throw new Error(`Unknown Camino cardinality: ${String(value)}`);
|
|
};
|
|
const fieldStorageKindFromOption = (value) => {
|
|
if (value === 5) {
|
|
return "static_final";
|
|
}
|
|
const normalized = lowerEnumName(value);
|
|
if (!value || normalized === "field_storage_kind_unspecified") {
|
|
return "stored";
|
|
}
|
|
if (normalized === "stored" ||
|
|
normalized === "derived" ||
|
|
normalized === "lazy" ||
|
|
normalized === "external" ||
|
|
normalized === "static_final") {
|
|
return normalized;
|
|
}
|
|
throw new Error(`Unknown Camino field storage kind: ${String(value)}`);
|
|
};
|
|
const fieldStorageFromOption = (value) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return {
|
|
kind: "stored",
|
|
cache: false,
|
|
};
|
|
}
|
|
const kind = fieldStorageKindFromOption(object.kind);
|
|
const resolver = object.resolver === undefined
|
|
? undefined
|
|
: functionRefFromOption(object.resolver);
|
|
if ((kind === "derived" || kind === "lazy" || kind === "external") && !resolver) {
|
|
throw new Error(`${kind} field storage requires resolver`);
|
|
}
|
|
return {
|
|
kind,
|
|
...(resolver ? { resolver } : {}),
|
|
cache: object.cache === true,
|
|
};
|
|
};
|
|
const fieldOpsFromOption = (value) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return undefined;
|
|
}
|
|
const implementation = enumName(object.implementation);
|
|
if (implementation !== "SERVICE") {
|
|
throw new Error(`Unsupported Camino field implementation: ${String(object.implementation)}`);
|
|
}
|
|
const service = readString(object, "service");
|
|
if (!service) {
|
|
throw new Error("SERVICE field_ops requires service");
|
|
}
|
|
return {
|
|
implementation: "service",
|
|
service,
|
|
};
|
|
};
|
|
const extractFileDefaults = (sourceFile) => {
|
|
const text = fs.readFileSync(sourceFile, "utf8");
|
|
const packageMatch = /^\s*package\s+([a-zA-Z0-9_.]+)\s*;/m.exec(text);
|
|
const namespaceMatch = /^\s*option\s+\(camino\.schema_namespace\)\s*=\s*"([^"]+)"\s*;/m.exec(text);
|
|
const versionMatch = /^\s*option\s+\(camino\.schema_version\)\s*=\s*"([^"]+)"\s*;/m.exec(text);
|
|
return {
|
|
packageName: packageMatch?.[1] ?? "",
|
|
schemaNamespace: namespaceMatch?.[1] ?? packageMatch?.[1] ?? "",
|
|
schemaVersion: versionMatch?.[1] ?? "1",
|
|
};
|
|
};
|
|
const protoSymbolFromReflection = (reflection, fallbackVersion) => {
|
|
if (!reflection?.fullName) {
|
|
return undefined;
|
|
}
|
|
const parts = reflection.fullName.replace(/^\./, "").split(".");
|
|
const name = parts.pop();
|
|
if (!name) {
|
|
return undefined;
|
|
}
|
|
return {
|
|
namespace: parts.join("."),
|
|
name,
|
|
version: fallbackVersion,
|
|
};
|
|
};
|
|
const typeRefForField = (field, schemaVersion) => {
|
|
const symbol = protoSymbolFromReflection(field.resolvedType, schemaVersion);
|
|
const enumValues = field.resolvedType instanceof protobuf.Enum
|
|
? Object.entries(field.resolvedType.values)
|
|
.filter(([_name, value]) => value !== 0)
|
|
.map(([name]) => name)
|
|
: undefined;
|
|
return {
|
|
protoType: field.type,
|
|
...(symbol ? { symbol } : {}),
|
|
...(enumValues ? { enumValues } : {}),
|
|
};
|
|
};
|
|
const typeRefForType = (type, fallbackType, schemaVersion) => {
|
|
const symbol = protoSymbolFromReflection(type ?? null, schemaVersion);
|
|
return {
|
|
protoType: type?.fullName?.replace(/^\./, "") ?? fallbackType,
|
|
...(symbol ? { symbol } : {}),
|
|
};
|
|
};
|
|
const fieldSchemaFromField = (field, schemaVersion) => {
|
|
const storage = fieldStorageFromOption(getReflectionOption(field, FIELD_STORAGE_OPTION));
|
|
const ops = fieldOpsFromOption(getReflectionOption(field, FIELD_OPS_OPTION));
|
|
if (ops && storage.kind !== "stored" && storage.kind !== "static_final") {
|
|
throw new Error(`Field ${field.fullName} cannot declare both field_ops and package-resolved storage`);
|
|
}
|
|
if (storage.kind === "static_final" && !ops) {
|
|
throw new Error(`Field ${field.fullName} with static_final storage requires field_ops`);
|
|
}
|
|
const interfaceContract = interfaceFieldContractFromOption(getReflectionOption(field, INTERFACE_FIELD_OPTION), schemaVersion);
|
|
return {
|
|
name: field.name,
|
|
tag: field.id,
|
|
type: typeRefForField(field, schemaVersion),
|
|
conflict: conflictFromOption(getReflectionOption(field, CONFLICT_OPTION)),
|
|
repeated: field.repeated,
|
|
optional: field.optional,
|
|
storage,
|
|
...(ops ? { ops } : {}),
|
|
...(interfaceContract ? { interfaceContract } : {}),
|
|
isDisplayLabel: getReflectionOption(field, DISPLAY_LABEL_OPTION) === true,
|
|
};
|
|
};
|
|
const isManyCardinality = (cardinality) => cardinality === "many" ||
|
|
cardinality === "many_unique" ||
|
|
cardinality === "many_ordered" ||
|
|
cardinality === "many_unique_ordered";
|
|
const materializationFromOption = (value, fallbackVersion) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return undefined;
|
|
}
|
|
const classRef = symbolRefFromOption(object.class, {
|
|
namespace: "",
|
|
name: "",
|
|
version: fallbackVersion,
|
|
});
|
|
if (!classRef.name) {
|
|
throw new Error("Edge materialization requires class");
|
|
}
|
|
return {
|
|
class: classRef,
|
|
connectProjection: readString(object, "connect_projection") ?? "",
|
|
};
|
|
};
|
|
const endpointFromOption = (params) => {
|
|
const object = asObject(params.option);
|
|
const classRef = asObject(object?.class)
|
|
? symbolRefFromOption(object?.class, {
|
|
namespace: "",
|
|
name: "",
|
|
version: params.fallbackVersion,
|
|
})
|
|
: params.fallbackClass;
|
|
const interfaceRef = asObject(object?.interface)
|
|
? symbolRefFromOption(object?.interface, {
|
|
namespace: "",
|
|
name: "",
|
|
version: params.fallbackVersion,
|
|
})
|
|
: undefined;
|
|
const projection = readString(object, "projection") ?? params.fallbackProjection;
|
|
const cardinality = object?.cardinality === undefined
|
|
? params.fallbackCardinality
|
|
: cardinalityFromOption(object.cardinality);
|
|
const materialization = materializationFromOption(object?.materialize, params.fallbackVersion);
|
|
if (!classRef?.name && !interfaceRef?.name) {
|
|
throw new Error(`Edge endpoint ${projection} requires class or interface`);
|
|
}
|
|
return {
|
|
...(classRef?.name ? { class: classRef } : {}),
|
|
...(interfaceRef?.name ? { interface: interfaceRef } : {}),
|
|
projection,
|
|
cardinality,
|
|
indexed: readBoolean(object, "indexed") ?? false,
|
|
...(materialization ? { materialization } : {}),
|
|
};
|
|
};
|
|
const symbolKey = (ref) => ref ? [ref.namespace, ref.name, ref.version, ref.hash ?? ""].join(":") : "";
|
|
const endpointRoleKey = (endpoint) => [
|
|
symbolKey(endpoint.class),
|
|
symbolKey(endpoint.interface),
|
|
endpoint.projection,
|
|
endpoint.cardinality,
|
|
].join("|");
|
|
const normalizeEdgeEndpoints = (params) => {
|
|
if (params.directionality === "directed") {
|
|
return {
|
|
fromEndpoint: params.fromEndpoint,
|
|
toEndpoint: params.toEndpoint,
|
|
};
|
|
}
|
|
return endpointRoleKey(params.fromEndpoint) <= endpointRoleKey(params.toEndpoint)
|
|
? {
|
|
fromEndpoint: params.fromEndpoint,
|
|
toEndpoint: params.toEndpoint,
|
|
}
|
|
: {
|
|
fromEndpoint: params.toEndpoint,
|
|
toEndpoint: params.fromEndpoint,
|
|
};
|
|
};
|
|
const symbolArrayFromOption = (value, defaults) => asArray(value)
|
|
.map((item) => symbolRefFromOption(item, {
|
|
namespace: defaults.schemaNamespace,
|
|
name: "",
|
|
version: defaults.schemaVersion,
|
|
}))
|
|
.filter((symbol) => Boolean(symbol.name));
|
|
const isStringType = (type) => type.protoType === "string" || type.protoType === "google.protobuf.StringValue";
|
|
const validateDisplayLabelFields = (type, fields, operationServices) => {
|
|
const displayLabelFields = fields.filter((field) => field.isDisplayLabel);
|
|
if (displayLabelFields.length > 1) {
|
|
throw new Error(`Class ${type.fullName} declares multiple Camino display label fields`);
|
|
}
|
|
const displayLabelField = displayLabelFields[0];
|
|
if (!displayLabelField) {
|
|
return;
|
|
}
|
|
if (!displayLabelField.ops) {
|
|
if (!isStringType(displayLabelField.type)) {
|
|
throw new Error(`Display label field ${type.fullName}.${displayLabelField.name} must have string type`);
|
|
}
|
|
return;
|
|
}
|
|
const serviceName = displayLabelField.ops.service.replace(/^\./, "");
|
|
const getOperation = operationServices
|
|
.find((service) => service.fullName === serviceName)
|
|
?.operations.find((operation) => operation.name === "Get");
|
|
if (!getOperation || !isStringType(getOperation.outputType)) {
|
|
throw new Error(`Display label field ${type.fullName}.${displayLabelField.name} must resolve to string`);
|
|
}
|
|
};
|
|
const typeBindingFromOption = (value, schemaVersion) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
return undefined;
|
|
}
|
|
const name = readString(object, "name");
|
|
const type = typeRefFromOption(object.type, schemaVersion);
|
|
if (!name || !type) {
|
|
throw new Error("Interface type_binding requires name and type");
|
|
}
|
|
return { name, type };
|
|
};
|
|
const interfaceImplementationFromOption = (value, defaults) => {
|
|
const object = asObject(value);
|
|
if (!object) {
|
|
throw new Error("Expected implements option object");
|
|
}
|
|
const interfaceId = symbolRefFromOption(object.interface, {
|
|
namespace: defaults.schemaNamespace,
|
|
name: "",
|
|
version: defaults.schemaVersion,
|
|
});
|
|
if (!interfaceId.name) {
|
|
throw new Error("implements option requires interface name");
|
|
}
|
|
return {
|
|
interface: interfaceId,
|
|
typeBindings: asArray(object.type_binding)
|
|
.map((binding) => typeBindingFromOption(binding, defaults.schemaVersion))
|
|
.filter((binding) => Boolean(binding)),
|
|
};
|
|
};
|
|
const serviceName = (service) => service.fullName.replace(/^\./, "");
|
|
const operationFromMethod = (method, schemaVersion) => {
|
|
const fn = functionRefFromOption(getReflectionOption(method, IMPL_OPTION));
|
|
const methodWithTypes = method;
|
|
return {
|
|
name: method.name,
|
|
inputType: typeRefForType(methodWithTypes.resolvedRequestType, method.requestType, schemaVersion),
|
|
outputType: typeRefForType(methodWithTypes.resolvedResponseType, method.responseType, schemaVersion),
|
|
function: fn,
|
|
};
|
|
};
|
|
const operationServiceFromService = (service, schemaVersion) => ({
|
|
name: service.name,
|
|
fullName: serviceName(service),
|
|
operations: service.methodsArray.map((method) => operationFromMethod(method, schemaVersion)),
|
|
});
|
|
const classSchemaFromType = (type, sourceFile, defaults, operationServices) => {
|
|
const classOption = asObject(getReflectionOption(type, CLASS_OPTION));
|
|
if (!classOption) {
|
|
return undefined;
|
|
}
|
|
const fallbackClassRef = {
|
|
namespace: defaults.schemaNamespace,
|
|
name: type.name,
|
|
version: defaults.schemaVersion,
|
|
};
|
|
const classId = symbolRefFromOption(classOption.id, fallbackClassRef);
|
|
const classVersion = readNumber(classOption, "version") ?? Number(classId.version);
|
|
if (!Number.isInteger(classVersion) || classVersion <= 0) {
|
|
throw new Error(`Class ${type.fullName} has invalid Camino class version`);
|
|
}
|
|
const fields = type.fieldsArray.map((field) => fieldSchemaFromField(field, defaults.schemaVersion));
|
|
validateDisplayLabelFields(type, fields, operationServices);
|
|
const edges = type.fieldsArray.flatMap((field) => {
|
|
const edgeOption = asObject(getReflectionOption(field, EDGE_OPTION));
|
|
if (!edgeOption) {
|
|
return [];
|
|
}
|
|
const legacyTargetClass = symbolRefFromOption(edgeOption.target, {
|
|
namespace: defaults.schemaNamespace,
|
|
name: "",
|
|
version: defaults.schemaVersion,
|
|
});
|
|
const cardinality = cardinalityFromOption(edgeOption.cardinality);
|
|
const declaredFromEndpoint = endpointFromOption({
|
|
option: edgeOption.this_endpoint,
|
|
fallbackClass: classId,
|
|
fallbackProjection: field.name,
|
|
fallbackCardinality: cardinality,
|
|
fallbackVersion: defaults.schemaVersion,
|
|
});
|
|
const declaredToEndpoint = endpointFromOption({
|
|
option: edgeOption.other_endpoint,
|
|
fallbackClass: legacyTargetClass.name ? legacyTargetClass : undefined,
|
|
fallbackProjection: readString(edgeOption, "inverse") ?? "",
|
|
fallbackCardinality: "many",
|
|
fallbackVersion: defaults.schemaVersion,
|
|
});
|
|
if (!declaredToEndpoint.projection) {
|
|
throw new Error(`Edge field ${type.fullName}.${field.name} requires other_endpoint.projection or inverse`);
|
|
}
|
|
const sourceType = typeRefForField(field, defaults.schemaVersion);
|
|
if (sourceType.symbol?.namespace !== "camino" ||
|
|
sourceType.symbol.name !== "Ref") {
|
|
throw new Error(`Edge field ${type.fullName}.${field.name} must use camino.Ref`);
|
|
}
|
|
const isMany = isManyCardinality(declaredFromEndpoint.cardinality);
|
|
if (isMany && !field.repeated) {
|
|
throw new Error(`Edge field ${type.fullName}.${field.name} must be repeated for ${declaredFromEndpoint.cardinality}`);
|
|
}
|
|
if (!isMany && field.repeated) {
|
|
throw new Error(`Edge field ${type.fullName}.${field.name} must not be repeated for ${declaredFromEndpoint.cardinality}`);
|
|
}
|
|
const directionality = edgeOption.undirected === true ? "undirected" : "directed";
|
|
const { fromEndpoint, toEndpoint } = normalizeEdgeEndpoints({
|
|
directionality,
|
|
fromEndpoint: declaredFromEndpoint,
|
|
toEndpoint: declaredToEndpoint,
|
|
});
|
|
const edgeId = symbolRefFromOption(edgeOption.id, {
|
|
namespace: defaults.schemaNamespace,
|
|
name: `${type.name}.${field.name}`,
|
|
version: defaults.schemaVersion,
|
|
});
|
|
const fallbackToClass = toEndpoint.class ?? {
|
|
namespace: "",
|
|
name: "",
|
|
version: "",
|
|
};
|
|
return [
|
|
{
|
|
id: edgeId,
|
|
directionality,
|
|
sourceField: fromEndpoint.projection,
|
|
fromClass: fromEndpoint.class ?? classId,
|
|
toClass: fallbackToClass,
|
|
cardinality: fromEndpoint.cardinality,
|
|
...(toEndpoint.projection
|
|
? { inverse: toEndpoint.projection }
|
|
: {}),
|
|
fields: [],
|
|
fromEndpoint,
|
|
toEndpoint,
|
|
declaringClass: classId,
|
|
tags: symbolArrayFromOption(edgeOption.tag, defaults),
|
|
implements: symbolArrayFromOption(edgeOption.implements, defaults),
|
|
},
|
|
];
|
|
});
|
|
const methods = getReflectionOptions(type, METHOD_OPTION)
|
|
.map(asObject)
|
|
.filter((option) => Boolean(option))
|
|
.map((option) => {
|
|
const name = readString(option, "name");
|
|
if (!name) {
|
|
throw new Error(`Method option on ${type.fullName} requires name`);
|
|
}
|
|
return {
|
|
name,
|
|
function: functionRefFromOption(option.function),
|
|
};
|
|
});
|
|
const migrations = getReflectionOptions(type, MIGRATION_OPTION)
|
|
.map(asObject)
|
|
.filter((option) => Boolean(option))
|
|
.map((option) => {
|
|
const fromVersion = readNumber(option, "from_version");
|
|
const toVersion = readNumber(option, "to_version");
|
|
if (!fromVersion || !toVersion) {
|
|
throw new Error(`Migration option on ${type.fullName} requires versions`);
|
|
}
|
|
return {
|
|
fromVersion,
|
|
toVersion,
|
|
function: functionRefFromOption(option.function),
|
|
};
|
|
});
|
|
const constructorOption = asObject(getReflectionOption(type, CONSTRUCTOR_OPTION));
|
|
const constructorSpec = constructorOption
|
|
? { function: functionRefFromOption(constructorOption.function) }
|
|
: undefined;
|
|
return {
|
|
id: classId,
|
|
version: classVersion,
|
|
fields,
|
|
edges,
|
|
methods,
|
|
migrations,
|
|
operationServices,
|
|
implements: getReflectionOptions(type, IMPLEMENTS_OPTION).map((option) => interfaceImplementationFromOption(option, defaults)),
|
|
...(constructorSpec ? { constructorSpec } : {}),
|
|
sourceFile,
|
|
protoMessage: type.fullName,
|
|
};
|
|
};
|
|
const interfaceSchemaFromType = (type, sourceFile, defaults) => {
|
|
const interfaceOption = asObject(getReflectionOption(type, INTERFACE_OPTION));
|
|
if (!interfaceOption) {
|
|
return undefined;
|
|
}
|
|
const classOption = asObject(getReflectionOption(type, CLASS_OPTION));
|
|
if (classOption) {
|
|
throw new Error(`${type.fullName} cannot be both a Camino class and interface`);
|
|
}
|
|
const fallbackInterfaceRef = {
|
|
namespace: defaults.schemaNamespace,
|
|
name: type.name,
|
|
version: defaults.schemaVersion,
|
|
};
|
|
const interfaceId = symbolRefFromOption(interfaceOption.id, fallbackInterfaceRef);
|
|
const interfaceVersion = readNumber(interfaceOption, "version") ?? Number(interfaceId.version);
|
|
if (!Number.isInteger(interfaceVersion) || interfaceVersion <= 0) {
|
|
throw new Error(`Interface ${type.fullName} has invalid Camino interface version`);
|
|
}
|
|
return {
|
|
id: interfaceId,
|
|
version: interfaceVersion,
|
|
fields: type.fieldsArray.map((field) => fieldSchemaFromField(field, defaults.schemaVersion)),
|
|
sourceFile,
|
|
protoMessage: type.fullName,
|
|
typeParameters: asArray(interfaceOption.type_parameter)
|
|
.map((entry) => String(entry).trim())
|
|
.filter(Boolean),
|
|
};
|
|
};
|
|
const walkTypes = (namespace, visit) => {
|
|
for (const nested of namespace.nestedArray) {
|
|
if (nested instanceof protobuf.Type) {
|
|
visit(nested);
|
|
walkTypes(nested, visit);
|
|
}
|
|
else if (nested instanceof protobuf.Namespace) {
|
|
walkTypes(nested, visit);
|
|
}
|
|
}
|
|
};
|
|
const walkServices = (namespace, visit) => {
|
|
for (const nested of namespace.nestedArray) {
|
|
if (nested instanceof protobuf.Service) {
|
|
visit(nested);
|
|
}
|
|
else if (nested instanceof protobuf.Namespace) {
|
|
walkServices(nested, visit);
|
|
}
|
|
}
|
|
};
|
|
export const loadCaminoSchemaRoot = async (sourceFile) => {
|
|
const absoluteSourceFile = path.resolve(sourceFile);
|
|
const root = new protobuf.Root();
|
|
const envIncludeDirs = [
|
|
process.env.QUIXOS_PROTO_PATH,
|
|
process.env.CAMINO_PROTO_PATH,
|
|
]
|
|
.filter((value) => Boolean(value))
|
|
.join(path.delimiter)
|
|
.split(path.delimiter)
|
|
.map((entry) => entry.trim())
|
|
.filter(Boolean)
|
|
.map((entry) => path.resolve(entry));
|
|
const includeDirs = [
|
|
path.dirname(absoluteSourceFile),
|
|
path.resolve("../../quixos-protocol/proto"),
|
|
path.resolve("quixos-protocol/proto"),
|
|
path.resolve("proto"),
|
|
...envIncludeDirs,
|
|
];
|
|
root.resolvePath = (origin, target) => {
|
|
if (path.isAbsolute(target) && fs.existsSync(target)) {
|
|
return target;
|
|
}
|
|
const originDir = origin ? path.dirname(origin) : undefined;
|
|
const candidates = [
|
|
...(originDir ? [path.resolve(originDir, target)] : []),
|
|
...includeDirs.map((dir) => path.resolve(dir, target)),
|
|
];
|
|
const found = candidates.find((candidate) => fs.existsSync(candidate));
|
|
return found ?? target;
|
|
};
|
|
await root.load(absoluteSourceFile, { keepCase: true });
|
|
root.resolveAll();
|
|
return { absoluteSourceFile, root };
|
|
};
|
|
export const compileCaminoSchema = async (sourceFile) => {
|
|
const { absoluteSourceFile, root } = await loadCaminoSchemaRoot(sourceFile);
|
|
const defaults = extractFileDefaults(absoluteSourceFile);
|
|
const operationServices = [];
|
|
walkServices(root, (service) => {
|
|
operationServices.push(operationServiceFromService(service, defaults.schemaVersion));
|
|
});
|
|
const classes = [];
|
|
const interfaces = [];
|
|
walkTypes(root, (type) => {
|
|
const interfaceSchema = interfaceSchemaFromType(type, absoluteSourceFile, defaults);
|
|
if (interfaceSchema) {
|
|
interfaces.push(interfaceSchema);
|
|
}
|
|
const classSchema = classSchemaFromType(type, absoluteSourceFile, defaults, operationServices);
|
|
if (classSchema) {
|
|
classes.push(classSchema);
|
|
}
|
|
});
|
|
return {
|
|
sourceFile: absoluteSourceFile,
|
|
classes,
|
|
interfaces,
|
|
};
|
|
};
|