@cerbos/core/lib/convert/fromProtobuf.js

Common types used by the Cerbos client libraries

/* eslint-disable @typescript-eslint/no-deprecated */
import { toJson } from "@bufbuild/protobuf";
import { ValueSchema, timestampDate } from "@bufbuild/protobuf/wkt";
import { PolicySource_Database_Driver } from "@cerbos/api/cerbos/audit/v1/audit_pb";
import { Effect as EffectProtobuf } from "@cerbos/api/cerbos/effect/v1/effect_pb";
import { PlanResourcesFilter_Kind } from "@cerbos/api/cerbos/engine/v1/engine_pb";
import { ScopePermissions as ScopePermissionsProtobuf } from "@cerbos/api/cerbos/policy/v1/policy_pb";
import { InspectPoliciesResponse_Attribute_Kind, InspectPoliciesResponse_Constant_Kind, InspectPoliciesResponse_DerivedRole_Kind, InspectPoliciesResponse_Variable_Kind, } from "@cerbos/api/cerbos/response/v1/response_pb";
import { ValidationError_Source } from "@cerbos/api/cerbos/schema/v1/schema_pb";
import { HealthCheckResponse_ServingStatus } from "@cerbos/api/grpc/health/v1/health_pb";
import { CheckResourcesResponse, CheckResourcesResult, DatabaseDriver, Effect, InspectedAttributeKind, InspectedConstantKind, InspectedDerivedRoleKind, InspectedVariableKind, PlanExpression, PlanExpressionValue, PlanExpressionVariable, PlanKind, SchemaDefinition, ScopePermissions, ServiceStatus, ValidationErrorSource, } from "../types/external.js";
export function accessLogEntryFromProtobuf({ entry, }) {
    requireOneOf("ListAuditLogEntriesResponse.entry", entry, "accessLogEntry");
    const { callId, timestamp, peer, metadata, method, statusCode, oversized, policySource, } = entry.value;
    requireField("AccessLogEntry.timestamp", timestamp);
    requireField("AccessLogEntry.peer", peer);
    return {
        callId,
        timestamp: timestampDate(timestamp),
        peer: peerFromProtobuf(peer),
        metadata: auditLogMetadataFromProtobuf(metadata),
        method,
        statusCode,
        oversized,
        policySource: policySource && policySourceFromProtobuf(policySource),
    };
}
export function decisionLogEntryFromProtobuf({ entry, }) {
    requireOneOf("ListAuditLogEntriesResponse.entry", entry, "decisionLogEntry");
    const { callId, timestamp, peer, metadata, auditTrail, method, oversized, policySource, } = entry.value;
    requireField("DecisionLogEntry.timestamp", timestamp);
    requireField("DecisionLogEntry.peer", peer);
    return {
        callId,
        timestamp: timestampDate(timestamp),
        peer: peerFromProtobuf(peer),
        metadata: auditLogMetadataFromProtobuf(metadata),
        auditTrail: auditTrailFromProtobuf(auditTrail),
        method: decisionLogEntryMethodFromProtobuf(method),
        oversized,
        policySource: policySource && policySourceFromProtobuf(policySource),
    };
}
function peerFromProtobuf({ address, authInfo, userAgent, forwardedFor, }) {
    return {
        address,
        authInfo,
        userAgent,
        forwardedFor,
    };
}
function auditLogMetadataFromProtobuf(metadata) {
    return Object.fromEntries(Object.entries(metadata).map(([key, { values }]) => [key, values]));
}
/** @internal */
export function auditTrailFromProtobuf(auditTrail) {
    const { effectivePolicies = {} } = auditTrail ?? {};
    return {
        effectivePolicies: Object.fromEntries(Object.entries(effectivePolicies).map(([policyId, sourceAttributes]) => [
            policyId,
            sourceAttributesFromProtobuf(sourceAttributes),
        ])),
    };
}
function policySourceFromProtobuf({ source, }) {
    return transformOneOf("PolicySource.source", source, {
        blob: policySourceBlobFromProtobuf,
        database: policySourceDatabaseFromProtobuf,
        disk: policySourceDiskFromProtobuf,
        embeddedPdp: policySourceEmbeddedPDPFromProtobuf,
        git: policySourceGitFromProtobuf,
        hub: policySourceHubFromProtobuf,
    });
}
function policySourceBlobFromProtobuf({ bucketUrl, prefix, }) {
    return {
        kind: "blob",
        bucketUrl,
        prefix,
    };
}
function policySourceDatabaseFromProtobuf({ driver, }) {
    return {
        kind: "database",
        driver: translateEnum("PolicySource.Database.Driver", PolicySource_Database_Driver, driver, {
            [PolicySource_Database_Driver.UNSPECIFIED]: unexpected,
            [PolicySource_Database_Driver.MYSQL]: DatabaseDriver.MYSQL,
            [PolicySource_Database_Driver.POSTGRES]: DatabaseDriver.POSTGRES,
            [PolicySource_Database_Driver.SQLITE3]: DatabaseDriver.SQLITE3,
        }),
    };
}
function policySourceDiskFromProtobuf({ directory, }) {
    return {
        kind: "disk",
        directory,
    };
}
function policySourceEmbeddedPDPFromProtobuf({ url, commitHash, builtAt, }) {
    return {
        kind: "embeddedPDP",
        url,
        commit: commitHash,
        builtAt: builtAt && timestampDate(builtAt),
    };
}
function policySourceGitFromProtobuf({ repositoryUrl, branch, subdirectory, }) {
    return {
        kind: "git",
        repositoryUrl,
        branch,
        subdirectory,
    };
}
function policySourceHubFromProtobuf({ source, }) {
    return {
        kind: "hub",
        ...policySourceHubSourceFromProtobuf(source),
    };
}
function policySourceHubSourceFromProtobuf(source) {
    return transformOneOf("PolicySource.Hub.source", source, {
        deploymentId: policySourceHubDeploymentFromProtobuf,
        embeddedBundle: policySourceHubEmbeddedBundleFromProtobuf,
        label: policySourceHubLabelFromProtobuf,
        localBundle: policySourceHubLocalBundleFromProtobuf,
        playgroundId: policySourceHubPlaygroundFromProtobuf,
    });
}
function policySourceHubDeploymentFromProtobuf(deploymentId) {
    return { deploymentId };
}
function policySourceHubEmbeddedBundleFromProtobuf(embeddedBundle) {
    return { embeddedBundle: embeddedBundleFromProtobuf(embeddedBundle) };
}
function policySourceHubLabelFromProtobuf(label) {
    return { label };
}
function policySourceHubLocalBundleFromProtobuf(localBundle) {
    return { localBundle: localBundleFromProtobuf(localBundle) };
}
function policySourceHubPlaygroundFromProtobuf(playgroundId) {
    return { playgroundId };
}
function embeddedBundleFromProtobuf({ ruleId, scopes, }) {
    return {
        ruleId,
        scopes,
    };
}
function localBundleFromProtobuf({ path, }) {
    return { path };
}
function decisionLogEntryMethodFromProtobuf(method) {
    return transformOneOf("DecisionLogEntry.method", method, {
        checkResources: decisionLogEntryCheckResourcesFromProtobuf,
        planResources: decisionLogEntryPlanResourcesFromProtobuf,
    });
}
function decisionLogEntryCheckResourcesFromProtobuf({ inputs, outputs, error, }) {
    return {
        name: "CheckResources",
        inputs: inputs.map(checkInputFromProtobuf),
        outputs: outputs.map(checkOutputFromProtobuf),
        error: error || undefined,
    };
}
/** @internal */
export function checkInputFromProtobuf({ requestId, principal, resource, actions, auxData, }) {
    requireField("CheckInput.principal", principal);
    requireField("CheckInput.resource", resource);
    return {
        requestId,
        principal: principalFromProtobuf(principal),
        resource: resourceFromProtobuf(resource),
        actions,
        auxData: auxData && decodedAuxDataFromProtobuf(auxData),
    };
}
function principalFromProtobuf({ id, roles, attr, policyVersion, scope, }) {
    return {
        id,
        roles,
        attr: valuesFromProtobuf(attr),
        policyVersion,
        scope,
    };
}
function resourceFromProtobuf({ kind, id, attr, policyVersion, scope, }) {
    return {
        kind,
        id,
        attr: valuesFromProtobuf(attr),
        policyVersion,
        scope,
    };
}
function decodedAuxDataFromProtobuf({ jwt }) {
    return {
        jwt: valuesFromProtobuf(jwt),
    };
}
/** @internal */
export function valuesFromProtobuf(values) {
    return Object.fromEntries(Object.entries(values).map(([key, value]) => [
        key,
        valueFromProtobuf(value),
    ]));
}
function valueFromProtobuf(value) {
    return toJson(ValueSchema, value);
}
/** @internal */
export function checkOutputFromProtobuf({ requestId, resourceId, actions, effectiveDerivedRoles, validationErrors, outputs, }) {
    return {
        requestId,
        resourceId,
        actions: Object.fromEntries(Object.entries(actions).map(([action, effect]) => [
            action,
            checkOutputActionEffectFromProtobuf(effect),
        ])),
        effectiveDerivedRoles,
        validationErrors: validationErrors.map(validationErrorFromProtobuf),
        outputs: outputs.map(outputResultFromProtobuf),
    };
}
function checkOutputActionEffectFromProtobuf({ effect, policy, scope, }) {
    return {
        effect: effectFromProtobuf(effect),
        policy,
        scope,
    };
}
function decisionLogEntryPlanResourcesFromProtobuf({ input, output, error, }) {
    requireField("DecisionLogEntry.PlanResources.input", input);
    return {
        name: "PlanResources",
        input: planResourcesInputFromProtobuf(input),
        output: output && planResourcesOutputFromProtobuf(output),
        error: error || undefined,
    };
}
/** @internal */
export function planResourcesInputFromProtobuf({ requestId, principal, resource, action, actions, auxData, }) {
    requireField("PlanResourcesInput.principal", principal);
    requireField("PlanResourcesInput.resource", resource);
    return {
        requestId,
        principal: principalFromProtobuf(principal),
        resource: resourceQueryFromProtobuf(resource),
        ...planResourcesActionsFromProtobuf({ action, actions }),
        auxData: auxData && decodedAuxDataFromProtobuf(auxData),
    };
}
function resourceQueryFromProtobuf({ kind, attr, policyVersion, scope, }) {
    return {
        kind,
        attr: valuesFromProtobuf(attr),
        policyVersion,
        scope,
    };
}
/** @internal */
export function planResourcesOutputFromProtobuf({ requestId, filter, filterDebug, action, actions, policyVersion, scope, validationErrors, }) {
    const base = {
        requestId,
        ...planResourcesActionsFromProtobuf({ action, actions }),
        policyVersion,
        scope,
        validationErrors: validationErrors.map(validationErrorFromProtobuf),
    };
    requireField("PlanResourcesOutput.filter", filter);
    const kind = planKindFromProtobuf(filter.kind);
    if (kind !== PlanKind.CONDITIONAL) {
        return { ...base, kind };
    }
    requireField("PlanResourcesFilter.condition", filter.condition);
    return {
        ...base,
        kind,
        condition: planOperandFromProtobuf(filter.condition),
        conditionString: filterDebug,
    };
}
function planResourcesActionsFromProtobuf({ action, actions, }) {
    return {
        action: actions.length === 1 ? actions[0] : action, // eslint-disable-line @typescript-eslint/no-non-null-assertion
        actions: actions.length ? actions : [action],
    };
}
export function checkResourcesResponseFromProtobuf({ cerbosCallId, requestId, results, }) {
    return new CheckResourcesResponse({
        cerbosCallId,
        requestId,
        results: results.map(checkResourcesResultFromProtobuf),
    });
}
function checkResourcesResultFromProtobuf({ resource, actions, validationErrors, meta, outputs, }) {
    requireField("CheckResourcesResponse.ResultEntry.resource", resource);
    return new CheckResourcesResult({
        resource: checkResourcesResultResourceFromProtobuf(resource),
        actions: actionsFromProtobuf(actions),
        validationErrors: validationErrors.map(validationErrorFromProtobuf),
        metadata: meta && checkResourcesResultMetadataFromProtobuf(meta),
        outputs: outputs.map(outputResultFromProtobuf),
    });
}
function checkResourcesResultResourceFromProtobuf({ kind, id, policyVersion, scope, }) {
    return {
        kind,
        id,
        policyVersion,
        scope,
    };
}
function checkResourcesResultMetadataFromProtobuf({ actions, effectiveDerivedRoles, }) {
    return {
        actions: checkResourcesResultMetadataActionsFromProtobuf(actions),
        effectiveDerivedRoles,
    };
}
function checkResourcesResultMetadataActionsFromProtobuf(actions) {
    return Object.fromEntries(Object.entries(actions).map(([action, effect]) => [
        action,
        checkResourcesResultMetadataEffectFromProtobuf(effect),
    ]));
}
function checkResourcesResultMetadataEffectFromProtobuf({ matchedPolicy, matchedScope, }) {
    return {
        matchedPolicy,
        matchedScope,
    };
}
function actionsFromProtobuf(actions) {
    return Object.fromEntries(Object.entries(actions).map(([action, effect]) => [
        action,
        effectFromProtobuf(effect),
    ]));
}
function effectFromProtobuf(effect) {
    return effect === EffectProtobuf.ALLOW ? Effect.ALLOW : Effect.DENY;
}
function validationErrorFromProtobuf({ path, message, source, }) {
    return {
        path,
        message,
        source: validationErrorSourceFromProtobuf(source),
    };
}
function validationErrorSourceFromProtobuf(source) {
    return translateEnum("ValidationError.Source", ValidationError_Source, source, {
        [ValidationError_Source.UNSPECIFIED]: unexpected,
        [ValidationError_Source.PRINCIPAL]: ValidationErrorSource.PRINCIPAL,
        [ValidationError_Source.RESOURCE]: ValidationErrorSource.RESOURCE,
    });
}
function outputResultFromProtobuf({ src, val }) {
    return {
        source: src,
        value: val && valueFromProtobuf(val),
    };
}
export function deleteSchemasResponseFromProtobuf({ deletedSchemas, }) {
    return { deletedSchemas };
}
export function disablePoliciesResponseFromProtobuf({ disabledPolicies, }) {
    return { disabledPolicies };
}
export function enablePoliciesResponseFromProtobuf({ enabledPolicies, }) {
    return { enabledPolicies };
}
export function getPoliciesResponseFromProtobuf({ policies, }) {
    return { policies: policies.map(policyFromProtobuf) };
}
export function healthCheckResponseFromProtobuf({ status, }) {
    return {
        status: status === HealthCheckResponse_ServingStatus.SERVING
            ? ServiceStatus.SERVING
            : ServiceStatus.NOT_SERVING,
    };
}
/** @internal */
export function policyFromProtobuf({ apiVersion, description, disabled, metadata, variables, policyType, }) {
    return {
        apiVersion,
        description,
        disabled,
        metadata: metadata && policyMetadataFromProtobuf(metadata),
        variables,
        ...policyTypeFromProtobuf(policyType),
    };
}
function policyMetadataFromProtobuf({ annotations, hash, sourceAttributes, sourceFile, storeIdentifer, storeIdentifier, }) {
    return {
        annotations,
        hash,
        sourceAttributes: sourceAttributesFromProtobuf(sourceAttributes),
        sourceFile,
        storeIdentifer: storeIdentifier || storeIdentifer,
        storeIdentifier: storeIdentifier || storeIdentifer,
    };
}
function sourceAttributesFromProtobuf(sourceAttributes) {
    if (!sourceAttributes) {
        return {};
    }
    return valuesFromProtobuf(sourceAttributes.attributes);
}
function policyTypeFromProtobuf(policyType) {
    return transformOneOf("Policy.policyType", policyType, {
        derivedRoles: derivedRolesFromProtobuf,
        exportConstants: exportConstantsFromProtobuf,
        exportVariables: exportVariablesFromProtobuf,
        principalPolicy: principalPolicyFromProtobuf,
        resourcePolicy: resourcePolicyFromProtobuf,
        rolePolicy: rolePolicyFromProtobuf,
    });
}
function derivedRolesFromProtobuf({ name, definitions, constants, variables, }) {
    return {
        derivedRoles: {
            name,
            definitions: definitions.map(derivedRoleDefinitionFromProtobuf),
            constants: constants && constantsFromProtobuf(constants),
            variables: variables && variablesFromProtobuf(variables),
        },
    };
}
function derivedRoleDefinitionFromProtobuf({ name, parentRoles, condition, }) {
    return {
        name,
        parentRoles,
        condition: condition && conditionFromProtobuf(condition),
    };
}
function conditionFromProtobuf({ condition }) {
    requireOneOf("Condition.condition", condition, "match");
    return { match: matchFromProtobuf(condition.value) };
}
function matchFromProtobuf({ op }) {
    return transformOneOf("Match.op", op, {
        all: (all) => ({ all: matchesFromProtobuf(all) }),
        any: (any) => ({ any: matchesFromProtobuf(any) }),
        none: (none) => ({ none: matchesFromProtobuf(none) }),
        expr: (expr) => ({ expr }),
    });
}
function matchesFromProtobuf({ of }) {
    return { of: of.map(matchFromProtobuf) };
}
function constantsFromProtobuf({ import: imports, local, }) {
    return {
        import: imports,
        local: valuesFromProtobuf(local),
    };
}
function exportConstantsFromProtobuf({ name, definitions, }) {
    return {
        exportConstants: {
            name,
            definitions: valuesFromProtobuf(definitions),
        },
    };
}
function variablesFromProtobuf({ import: imports, local, }) {
    return {
        import: imports,
        local,
    };
}
function exportVariablesFromProtobuf({ name, definitions, }) {
    return {
        exportVariables: {
            name,
            definitions,
        },
    };
}
function principalPolicyFromProtobuf({ principal, version, rules, scope, scopePermissions, constants, variables, }) {
    return {
        principalPolicy: {
            principal,
            version,
            rules: rules.map(principalRuleFromProtobuf),
            scope,
            scopePermissions: scopePermissionsFromProtobuf(scopePermissions),
            constants: constants && constantsFromProtobuf(constants),
            variables: variables && variablesFromProtobuf(variables),
        },
    };
}
function principalRuleFromProtobuf({ resource, actions, }) {
    return {
        resource,
        actions: actions.map(principalRuleActionFromProtobuf),
    };
}
function principalRuleActionFromProtobuf({ action, effect, condition, name, output, }) {
    return {
        action,
        effect: effectFromProtobuf(effect),
        condition: condition && conditionFromProtobuf(condition),
        name,
        output: output && outputFromProtobuf(output),
    };
}
function outputFromProtobuf({ expr, when }) {
    const output = {};
    if (expr) {
        output.expr = expr;
    }
    if (when) {
        output.when = when;
    }
    return output;
}
function resourcePolicyFromProtobuf({ resource, version, importDerivedRoles, rules, schemas, scope, scopePermissions, constants, variables, }) {
    return {
        resourcePolicy: {
            resource,
            version,
            importDerivedRoles,
            rules: rules.map(resourceRuleFromProtobuf),
            schemas: schemas && schemaRefsFromProtobuf(schemas),
            scope,
            scopePermissions: scopePermissionsFromProtobuf(scopePermissions),
            constants: constants && constantsFromProtobuf(constants),
            variables: variables && variablesFromProtobuf(variables),
        },
    };
}
function resourceRuleFromProtobuf({ actions, effect, derivedRoles, roles, condition, name, output, }) {
    return {
        actions,
        effect: effectFromProtobuf(effect),
        derivedRoles,
        roles,
        condition: condition && conditionFromProtobuf(condition),
        name,
        output: output && outputFromProtobuf(output),
    };
}
function rolePolicyFromProtobuf({ policyType, parentRoles, scope, rules, }) {
    requireOneOf("RolePolicy.policyType", policyType, "role");
    return {
        rolePolicy: {
            role: policyType.value,
            parentRoles: parentRoles,
            scope,
            rules: rules.map(roleRuleFromProtobuf),
        },
    };
}
function roleRuleFromProtobuf({ resource, allowActions, }) {
    return {
        resource,
        allowActions,
    };
}
function scopePermissionsFromProtobuf(scopePermissions) {
    return translateEnum("ScopePermissions", ScopePermissionsProtobuf, scopePermissions, {
        [ScopePermissionsProtobuf.UNSPECIFIED]: undefined,
        [ScopePermissionsProtobuf.OVERRIDE_PARENT]: ScopePermissions.OVERRIDE_PARENT,
        [ScopePermissionsProtobuf.REQUIRE_PARENTAL_CONSENT_FOR_ALLOWS]: ScopePermissions.REQUIRE_PARENTAL_CONSENT_FOR_ALLOWS,
    });
}
function schemaRefsFromProtobuf({ principalSchema, resourceSchema, }) {
    return {
        principalSchema: principalSchema && schemaRefFromProtobuf(principalSchema),
        resourceSchema: resourceSchema && schemaRefFromProtobuf(resourceSchema),
    };
}
function schemaRefFromProtobuf({ ref, ignoreWhen }) {
    return {
        ref,
        ignoreWhen: ignoreWhen && { actions: ignoreWhen.actions },
    };
}
export function getSchemasResponseFromProtobuf({ schemas, }) {
    return { schemas: schemas.map(schemaFromProtobuf) };
}
function schemaFromProtobuf({ id, definition }) {
    return {
        id,
        definition: new SchemaDefinition(definition),
    };
}
export function inspectPoliciesResponseFromProtobuf({ results, }) {
    return {
        policies: Object.fromEntries(Object.entries(results).map(([id, result]) => [
            id,
            inspectedPolicyFromProtobuf(result),
        ])),
    };
}
function inspectedPolicyFromProtobuf({ policyId, actions, attributes, constants, derivedRoles, variables, }) {
    return {
        id: policyId,
        actions,
        attributes: attributes.map(inspectedAttributeFromProtobuf),
        constants: constants.map(inspectedConstantFromProtobuf),
        derivedRoles: derivedRoles.map(inspectedDerivedRoleFromProtobuf),
        variables: variables.map(inspectedVariableFromProtobuf),
    };
}
function inspectedAttributeFromProtobuf({ kind, name, }) {
    return {
        kind: inspectedAttributeKindFromProtobuf(kind),
        name,
    };
}
function inspectedAttributeKindFromProtobuf(kind) {
    return translateEnum("InspectPoliciesResponse.Attribute.Kind", InspectPoliciesResponse_Attribute_Kind, kind, {
        [InspectPoliciesResponse_Attribute_Kind.UNSPECIFIED]: unexpected,
        [InspectPoliciesResponse_Attribute_Kind.PRINCIPAL_ATTRIBUTE]: InspectedAttributeKind.PRINCIPAL,
        [InspectPoliciesResponse_Attribute_Kind.RESOURCE_ATTRIBUTE]: InspectedAttributeKind.RESOURCE,
    });
}
function inspectedConstantFromProtobuf({ kind, name, value, source, used, }) {
    return {
        kind: inspectedConstantKindFromProtobuf(kind),
        name,
        value: value && valueFromProtobuf(value),
        source: source || undefined,
        used,
    };
}
function inspectedConstantKindFromProtobuf(kind) {
    return translateEnum("InspectPoliciesResponse.Constant.Kind", InspectPoliciesResponse_Constant_Kind, kind, {
        [InspectPoliciesResponse_Constant_Kind.UNSPECIFIED]: unexpected,
        [InspectPoliciesResponse_Constant_Kind.EXPORTED]: InspectedConstantKind.EXPORTED,
        [InspectPoliciesResponse_Constant_Kind.IMPORTED]: InspectedConstantKind.IMPORTED,
        [InspectPoliciesResponse_Constant_Kind.LOCAL]: InspectedConstantKind.LOCAL,
        [InspectPoliciesResponse_Constant_Kind.UNDEFINED]: InspectedConstantKind.UNDEFINED,
        [InspectPoliciesResponse_Constant_Kind.UNKNOWN]: InspectedConstantKind.UNKNOWN,
    });
}
function inspectedDerivedRoleFromProtobuf({ kind, name, source, }) {
    return {
        kind: inspectedDerivedRoleKindFromProtobuf(kind),
        name,
        source: source || undefined,
    };
}
function inspectedDerivedRoleKindFromProtobuf(kind) {
    return translateEnum("InspectPoliciesResponse.DerivedRole.Kind", InspectPoliciesResponse_DerivedRole_Kind, kind, {
        [InspectPoliciesResponse_DerivedRole_Kind.UNSPECIFIED]: unexpected,
        [InspectPoliciesResponse_DerivedRole_Kind.EXPORTED]: InspectedDerivedRoleKind.EXPORTED,
        [InspectPoliciesResponse_DerivedRole_Kind.IMPORTED]: InspectedDerivedRoleKind.IMPORTED,
        [InspectPoliciesResponse_DerivedRole_Kind.UNDEFINED]: InspectedDerivedRoleKind.UNDEFINED,
    });
}
function inspectedVariableFromProtobuf({ kind, name, value, source, used, }) {
    return {
        kind: inspectedVariableKindFromProtobuf(kind),
        name,
        definition: value || undefined,
        source: source || undefined,
        used,
    };
}
function inspectedVariableKindFromProtobuf(kind) {
    return translateEnum("InspectPoliciesResponse.Variable.Kind", InspectPoliciesResponse_Variable_Kind, kind, {
        [InspectPoliciesResponse_Variable_Kind.UNSPECIFIED]: unexpected,
        [InspectPoliciesResponse_Variable_Kind.EXPORTED]: InspectedVariableKind.EXPORTED,
        [InspectPoliciesResponse_Variable_Kind.IMPORTED]: InspectedVariableKind.IMPORTED,
        [InspectPoliciesResponse_Variable_Kind.LOCAL]: InspectedVariableKind.LOCAL,
        [InspectPoliciesResponse_Variable_Kind.UNDEFINED]: InspectedVariableKind.UNDEFINED,
        [InspectPoliciesResponse_Variable_Kind.UNKNOWN]: InspectedVariableKind.UNKNOWN,
    });
}
export function listPoliciesResponseFromProtobuf({ policyIds, }) {
    return { ids: policyIds };
}
export function listSchemasResponseFromProtobuf({ schemaIds, }) {
    return { ids: schemaIds };
}
export function planResourcesResponseFromProtobuf({ cerbosCallId, requestId, filter, validationErrors, meta, }) {
    const base = {
        cerbosCallId,
        requestId,
        validationErrors: validationErrors.map(validationErrorFromProtobuf),
        metadata: meta && planResourcesMetadataFromProtobuf(meta),
    };
    requireField("PlanResourcesResponse.filter", filter);
    const kind = planKindFromProtobuf(filter.kind);
    if (kind !== PlanKind.CONDITIONAL) {
        return { ...base, kind };
    }
    requireField("PlanResourcesFilter.condition", filter.condition);
    return {
        ...base,
        kind,
        condition: planOperandFromProtobuf(filter.condition),
    };
}
function planKindFromProtobuf(kind) {
    return translateEnum("PlanResourcesFilter.Kind", PlanResourcesFilter_Kind, kind, {
        [PlanResourcesFilter_Kind.UNSPECIFIED]: unexpected,
        [PlanResourcesFilter_Kind.ALWAYS_ALLOWED]: PlanKind.ALWAYS_ALLOWED,
        [PlanResourcesFilter_Kind.ALWAYS_DENIED]: PlanKind.ALWAYS_DENIED,
        [PlanResourcesFilter_Kind.CONDITIONAL]: PlanKind.CONDITIONAL,
    });
}
function planOperandFromProtobuf({ node, }) {
    return transformOneOf("PlanResourcesFilter.Expression.Operand.node", node, {
        expression: (expression) => new PlanExpression(expression.operator, expression.operands.map(planOperandFromProtobuf)),
        value: (value) => new PlanExpressionValue(valueFromProtobuf(value)),
        variable: (variable) => new PlanExpressionVariable(variable),
    });
}
function planResourcesMetadataFromProtobuf({ filterDebug, matchedScope, matchedScopes, }) {
    return {
        conditionString: filterDebug,
        matchedScope,
        matchedScopes,
    };
}
export function serverInfoFromProtobuf({ buildDate, commit, version, }) {
    return {
        buildDate,
        commit,
        version,
    };
}
/** @internal */
export const unexpected = Symbol("unexpected");
function isUnexpected(value) {
    return value === unexpected;
}
/** @internal */
export function translateEnum(descriptor, source, value, translate) {
    if (value in translate) {
        const result = translate[value];
        if (!isUnexpected(result)) {
            return result;
        }
    }
    const wanted = Object.entries(source)
        .filter(([, value]) => typeof value === "number" &&
        !isUnexpected(translate[value]))
        .map(([key, value]) => `${key}:${value}`)
        .join("|");
    const got = source[value] ? `${source[value]}:${value}` : value;
    throw new Error(`Unexpected ${descriptor}: wanted ${wanted}, got ${got}`);
}
function transformOneOf(descriptor, oneOf, transforms) {
    requireField(descriptor, oneOf);
    const transform = transforms[oneOf.case];
    if (!transform || isUnexpected(transform)) {
        throw new Error(`Unexpected ${descriptor}: wanted ${Object.keys(transforms).join("|")}, got ${oneOf.case}`);
    }
    return transform(oneOf.value);
}
function requireOneOf(descriptor, oneOf, $case) {
    requireField(descriptor, oneOf);
    if (oneOf.case !== $case) {
        throw new Error(`Unexpected ${descriptor}: wanted ${$case}, got ${oneOf.case}`);
    }
}
/** @internal */
export function requireField(descriptor, value) {
    if (value === undefined) {
        throw new Error(`Missing ${descriptor}`);
    }
}
//# sourceMappingURL=fromProtobuf.js.map