@schoolai/spicedb-zed-schema-parser/dist/index.d.cts

SpiceDB .zed file format parser and analyzer written in Typescript

export { Operations, PermissionOperations, Permissions, createPermissions } from './builder/index.cjs';
import * as chevrotain from 'chevrotain';
import { Lexer, CstParser, ICstVisitor } from 'chevrotain';
import '@authzed/authzed-node';

declare const SpiceDBLexer: Lexer;
declare class SpiceDBParser extends CstParser {
    constructor();
    schema: chevrotain.ParserMethod<[], chevrotain.CstNode>;
    private caveatDefinition;
    private parameterList;
    private parameter;
    private caveatExpression;
    private objectTypeDefinition;
    private relationDeclaration;
    private relationTypes;
    private relationType;
    private permissionDeclaration;
    private permissionExpression;
    private unionExpression;
    private intersectionExpression;
    private exclusionExpression;
    private arrowExpression;
    private primaryExpression;
}
declare const parserInstance: SpiceDBParser;
interface SchemaAST {
    definitions: (CaveatDefinition | ObjectTypeDefinition)[];
}
interface CaveatDefinition {
    type: 'caveat';
    name: string;
    docComment?: string;
    parameters: Parameter[];
    expression: CaveatExpression;
}
interface Parameter {
    name: string;
    type: string;
}
interface CaveatExpression {
    left: string;
    operator: 'equals';
    right: number;
}
interface ObjectTypeDefinition {
    type: 'definition';
    name: string;
    docComment?: string;
    relations: RelationDeclaration[];
    permissions: PermissionDeclaration[];
}
interface RelationDeclaration {
    name: string;
    docComment?: string;
    types: RelationType[];
}
interface RelationType {
    typeName: string;
    wildcard?: boolean;
    relation?: string;
}
interface PermissionDeclaration {
    name: string;
    docComment?: string;
    expression: PermissionExpression;
}
type PermissionExpression = IdentifierExpression | UnionExpression | IntersectionExpression | ExclusionExpression | ArrowExpression | AnyExpression | AllExpression;
interface IdentifierExpression {
    type: 'identifier';
    name: string;
}
interface UnionExpression {
    type: 'union';
    operands: PermissionExpression[];
}
interface IntersectionExpression {
    type: 'intersection';
    operands: PermissionExpression[];
}
interface ExclusionExpression {
    type: 'exclusion';
    left: PermissionExpression;
    right: PermissionExpression;
}
interface ArrowExpression {
    type: 'arrow';
    left: PermissionExpression;
    target: string;
}
interface AnyExpression {
    type: 'any';
    left: PermissionExpression;
    target: string;
}
interface AllExpression {
    type: 'all';
    left: PermissionExpression;
    target: string;
}
declare const BaseVisitor: new (...args: any[]) => ICstVisitor<any, any>;
declare class SpiceDBVisitor extends BaseVisitor implements ICstVisitor<any, any> {
    constructor();
    schema(ctx: any): SchemaAST;
    caveatDefinition(ctx: any): CaveatDefinition;
    parameterList(ctx: any): Parameter[];
    parameter(ctx: any): Parameter;
    caveatExpression(ctx: any): CaveatExpression;
    objectTypeDefinition(ctx: any): ObjectTypeDefinition;
    relationDeclaration(ctx: any): RelationDeclaration;
    relationTypes(ctx: any): RelationType[];
    relationType(ctx: any): RelationType;
    permissionDeclaration(ctx: any): PermissionDeclaration;
    permissionExpression(ctx: any): PermissionExpression;
    unionExpression(ctx: any): PermissionExpression;
    intersectionExpression(ctx: any): PermissionExpression;
    exclusionExpression(ctx: any): PermissionExpression;
    arrowExpression(ctx: any): PermissionExpression;
    primaryExpression(ctx: any): PermissionExpression;
}
interface ParseResult {
    ast?: SchemaAST;
    errors: Array<{
        message: string;
        line: number;
        column: number;
    }>;
}
declare function parseSpiceDBSchema(text: string): ParseResult;

interface SemanticError {
    type: 'semantic_error';
    code: string;
    message: string;
    location?: {
        definition?: string;
        relation?: string;
        permission?: string;
    };
}
interface SchemaAnalysisResult {
    augmentedAst?: AugmentedSchemaAST;
    symbolTable: any;
    errors: SemanticError[];
    warnings: SemanticError[];
    isValid: boolean;
}
interface AugmentedSchemaAST {
    definitions: (AugmentedObjectTypeDefinition | CaveatDefinition)[];
}
interface AugmentedObjectTypeDefinition {
    type: 'definition';
    name: string;
    relations: AugmentedRelationDeclaration[];
    permissions: AugmentedPermissionDeclaration[];
    comments?: string[];
}
interface AugmentedRelationDeclaration extends RelationDeclaration {
}
interface AugmentedPermissionDeclaration extends PermissionDeclaration {
    inferredSubjectTypes: RelationType[] | null;
}

/**
 * Generates the TypeScript code for a permissions SDK based on a zed schema.
 * @param schema The augmented schema AST.
 * @returns The generated TypeScript code as a string.
 */
declare function generateSDK(schema: AugmentedSchemaAST, parserImport?: string): string;

declare class SemanticAnalyzer {
    private symbolTable;
    private typeInference;
    private errors;
    private warnings;
    constructor();
    analyze(ast: SchemaAST): SchemaAnalysisResult;
    private augmentAst;
    private buildSymbolTable;
    private validateDefinitions;
    private validateObjectTypeDefinition;
    private validateRelation;
    private validateCaveatDefinition;
    private checkForCycles;
    private addExpressionDependencies;
    private validateExpressions;
    private validateExpression;
    private performAdditionalChecks;
    private isEmptyPermission;
    private addError;
    private addWarning;
}
declare function analyzeSpiceDbSchema(ast: SchemaAST): SchemaAnalysisResult;

export { type AllExpression, type AnyExpression, type ArrowExpression, type CaveatDefinition, type CaveatExpression, type ExclusionExpression, type IdentifierExpression, type IntersectionExpression, type ObjectTypeDefinition, type Parameter, type ParseResult, type PermissionDeclaration, type PermissionExpression, type RelationDeclaration, type RelationType, type SchemaAST, SemanticAnalyzer, SpiceDBLexer, SpiceDBParser, SpiceDBVisitor, type UnionExpression, analyzeSpiceDbSchema, generateSDK, parseSpiceDBSchema, parserInstance };