pyric 0.0.1 → 0.1.0-alpha.7

package/dist/rules/grammar/FirestoreRules.ohm.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const FIRESTORE_RULES_OHM_SOURCE = "FirestoreRules {\n  // === Top-level ===\n  // Syntactic rules (capitalized) auto-skip spaces between terms.\n  // Lexical rules (lowercase) do NOT skip spaces.\n\n  // Two accepted orderings. Real `firestore.rules` files put\n  // `rules_version` at line 1 (Firebase convention), so the\n  // `versionFirst` branch matches that natural shape. The\n  // `importsFirst` branch keeps legacy samples that put `import`\n  // declarations above the version line working. The semantic\n  // action below normalizes both into the same AST shape, so\n  // downstream code doesn't have to care which path matched.\n  RulesFile = RulesVersion ImportDecl* ServiceBlock  -- versionFirst\n            | ImportDecl* RulesVersion ServiceBlock  -- importsFirst\n\n  ImportDecl = \"import\" \"{\" ListOf<ident, \",\"> \",\"? \"}\" \"from\" string \";\"\n\n  RulesVersion = \"rules_version\" \"=\" string \";\"\n\n  ServiceBlock = \"service\" serviceName \"{\" DocumentsMatch \"}\"\n\n  DocumentsMatch = \"match\" matchPath \"{\" MatchBody \"}\"\n\n  MatchBody = MatchBodyItem*\n\n  MatchBodyItem\n    = FunctionDef\n    | MatchBlock\n    | AllowStatement\n\n  MatchBlock = \"match\" matchPath \"{\" MatchBody \"}\"\n\n  // === Statements ===\n\n  AllowStatement = \"allow\" OperationList \":\" \"if\" Expr \";\"\n\n  OperationList = Operation (\",\" Operation)*\n\n  FunctionDef = \"export\"? \"function\" ident \"(\" ParameterList \")\" \"{\" FunctionBody \"}\"\n\n  ParameterList = ListOf<ident, \",\">\n\n  FunctionBody = LetBinding* ReturnStatement\n\n  LetBinding = \"let\" ident \"=\" Expr \";\"\n\n  ReturnStatement = \"return\" Expr \";\"\n\n  // === Lexical: operations and service name ===\n\n  Operation\n    = \"read\" ~identChar\n    | \"write\" ~identChar\n    | \"get\" ~identChar\n    | \"list\" ~identChar\n    | \"create\" ~identChar\n    | \"update\" ~identChar\n    | \"delete\" ~identChar\n\n  serviceName = letter (letter | \".\")*\n\n  // === Lexical: match paths ===\n\n  matchPath = \"/\" matchPathSegment (\"/\" matchPathSegment)*\n\n  matchPathSegment\n    = \"{\" matchWildcard \"}\"    -- wildcard\n    | pathIdent                -- literal\n\n  matchWildcard\n    = identStart identChar* \"=\" \"**\"  -- recursive\n    | identStart identChar*           -- single\n\n  pathIdent = (letter | digit | \"_\" | \"-\" | \".\")+\n\n  // === Expressions ===\n\n  Expr = Ternary\n\n  Ternary\n    = LogicalOr \"?\" Ternary \":\" Ternary  -- ternary\n    | LogicalOr\n\n  LogicalOr\n    = LogicalOr \"||\" LogicalAnd  -- or\n    | LogicalAnd\n\n  LogicalAnd\n    = LogicalAnd \"&&\" InIsExpr  -- and\n    | InIsExpr\n\n  InIsExpr\n    = Equality in Equality   -- in\n    | Equality is typeName   -- is\n    | Equality\n\n  in = \"in\" ~identChar\n  is = \"is\" ~identChar\n\n  Equality\n    = Equality \"==\" Comparison  -- eq\n    | Equality \"!=\" Comparison  -- neq\n    | Comparison\n\n  Comparison\n    = Comparison \">=\" Additive  -- gte\n    | Comparison \"<=\" Additive  -- lte\n    | Comparison \">\" Additive   -- gt\n    | Comparison \"<\" Additive   -- lt\n    | Additive\n\n  Additive\n    = Additive \"+\" Multiplicative  -- add\n    | Additive \"-\" Multiplicative  -- sub\n    | Multiplicative\n\n  Multiplicative\n    = Multiplicative \"*\" UnaryExpr  -- mul\n    | Multiplicative \"/\" UnaryExpr  -- div\n    | Multiplicative \"%\" UnaryExpr  -- mod\n    | UnaryExpr\n\n  UnaryExpr\n    = \"!\" UnaryExpr  -- not\n    | \"-\" UnaryExpr  -- neg\n    | PostfixExpr\n\n  PostfixExpr\n    = PostfixExpr \".\" memberName \"(\" ListOf<Expr, \",\"> \")\"  -- methodCall\n    | PostfixExpr \".\" memberName                             -- memberAccess\n    | PostfixExpr \"[\" Expr \":\" Expr \"]\"                      -- sliceAccess\n    | PostfixExpr \"[\" Expr \"]\"                               -- bracketAccess\n    | Primary\n\n  memberName = identStart identChar*\n\n  Primary\n    = \"(\" Expr \")\"       -- paren\n    | PathLiteral        -- path\n    | ListLiteral        -- list\n    | MapLiteral         -- map\n    | ident \"(\" ListOf<Expr, \",\"> \")\"  -- functionCall\n    | literal\n    | ident\n\n  // === Path literals ===\n\n  PathLiteral = \"/\" PathLitSegment (\"/\" PathLitSegment)*\n\n  PathLitSegment\n    = \"$(\" Expr \")\"    -- interpolation\n    | \"{\" ident \"}\"    -- captureRef\n    | pathIdent        -- literal\n\n  // === Literals ===\n\n  literal\n    = number\n    | string\n    | bool\n    | null\n\n  number\n    = digit+ \".\" digit+  -- float\n    | digit+              -- int\n\n  string\n    = \"'\" singleStringChar* \"'\"    -- single\n    | \"\\\"\" doubleStringChar* \"\\\"\"  -- double\n\n  singleStringChar\n    = \"\\\\\" stringEscapeChar  -- escape\n    | ~\"\\\\\" ~\"'\" any         -- char\n\n  doubleStringChar\n    = \"\\\\\" stringEscapeChar  -- escape\n    | ~\"\\\\\" ~\"\\\"\" any        -- char\n\n  // Valid escape characters following a backslash. Anything else is rejected\n  // at parse time to match production semantics \u2014 production Firestore Rules\n  // raises a syntax error on unknown escapes (e.g. `\\d`, `\\.`). Keeping the\n  // sim strict here prevents over-permissive acceptance that masks model\n  // output that would crash at deploy.\n  stringEscapeChar = \"\\\\\" | \"'\" | \"\\\"\" | \"n\" | \"r\" | \"t\" | \"/\"\n\n  ListLiteral = \"[\" ListOf<Expr, \",\"> \",\"? \"]\"\n\n  MapLiteral = \"{\" ListOf<MapEntry, \",\"> \",\"? \"}\"\n\n  MapEntry = (string | ident) \":\" Expr\n\n  bool\n    = \"true\" ~identChar   -- true\n    | \"false\" ~identChar  -- false\n\n  null = \"null\" ~identChar\n\n  typeName\n    = \"string\" ~identChar\n    | \"int\" ~identChar\n    | \"float\" ~identChar\n    | \"number\" ~identChar\n    | \"bool\" ~identChar\n    | \"list\" ~identChar\n    | \"map\" ~identChar\n    | \"timestamp\" ~identChar\n    | \"path\" ~identChar\n    | \"bytes\" ~identChar\n    | \"duration\" ~identChar\n    | \"latlng\" ~identChar\n    | \"reference\" ~identChar\n\n  ident = ~keyword identStart identChar*\n\n  keyword\n    = (\"true\" | \"false\" | \"null\" | \"in\" | \"is\" | \"if\" | \"return\" | \"let\") ~identChar\n\n  identStart = letter | \"_\"\n\n  identChar = alnum | \"_\"\n\n  // === Whitespace and comments ===\n\n  space += comment\n\n  comment\n    = \"//\" (~\"\\n\" any)* &(\"\\n\" | end)  -- singleLine\n    | \"/*\" (~\"*/\" any)* \"*/\"            -- multiLine\n}\n";
+//# sourceMappingURL=FirestoreRules.ohm.generated.d.ts.map

package/dist/rules/grammar/FirestoreRules.ohm.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirestoreRules.ohm.generated.d.ts","sourceRoot":"","sources":["../../../src/rules/grammar/FirestoreRules.ohm.generated.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B,8wMAqOtC,CAAC"}

package/dist/rules/grammar/FirestoreRules.ohm.generated.js

@@ -0,0 +1,234 @@
+// AUTO-GENERATED — do not edit by hand. Regenerate via:
+//   bun packages/sdk/scripts/inline-grammar.ts
+// Source: FirestoreRules.ohm
+export const FIRESTORE_RULES_OHM_SOURCE = `FirestoreRules {
+  // === Top-level ===
+  // Syntactic rules (capitalized) auto-skip spaces between terms.
+  // Lexical rules (lowercase) do NOT skip spaces.
+
+  // Two accepted orderings. Real \`firestore.rules\` files put
+  // \`rules_version\` at line 1 (Firebase convention), so the
+  // \`versionFirst\` branch matches that natural shape. The
+  // \`importsFirst\` branch keeps legacy samples that put \`import\`
+  // declarations above the version line working. The semantic
+  // action below normalizes both into the same AST shape, so
+  // downstream code doesn't have to care which path matched.
+  RulesFile = RulesVersion ImportDecl* ServiceBlock  -- versionFirst
+            | ImportDecl* RulesVersion ServiceBlock  -- importsFirst
+
+  ImportDecl = "import" "{" ListOf<ident, ","> ","? "}" "from" string ";"
+
+  RulesVersion = "rules_version" "=" string ";"
+
+  ServiceBlock = "service" serviceName "{" DocumentsMatch "}"
+
+  DocumentsMatch = "match" matchPath "{" MatchBody "}"
+
+  MatchBody = MatchBodyItem*
+
+  MatchBodyItem
+    = FunctionDef
+    | MatchBlock
+    | AllowStatement
+
+  MatchBlock = "match" matchPath "{" MatchBody "}"
+
+  // === Statements ===
+
+  AllowStatement = "allow" OperationList ":" "if" Expr ";"
+
+  OperationList = Operation ("," Operation)*
+
+  FunctionDef = "export"? "function" ident "(" ParameterList ")" "{" FunctionBody "}"
+
+  ParameterList = ListOf<ident, ",">
+
+  FunctionBody = LetBinding* ReturnStatement
+
+  LetBinding = "let" ident "=" Expr ";"
+
+  ReturnStatement = "return" Expr ";"
+
+  // === Lexical: operations and service name ===
+
+  Operation
+    = "read" ~identChar
+    | "write" ~identChar
+    | "get" ~identChar
+    | "list" ~identChar
+    | "create" ~identChar
+    | "update" ~identChar
+    | "delete" ~identChar
+
+  serviceName = letter (letter | ".")*
+
+  // === Lexical: match paths ===
+
+  matchPath = "/" matchPathSegment ("/" matchPathSegment)*
+
+  matchPathSegment
+    = "{" matchWildcard "}"    -- wildcard
+    | pathIdent                -- literal
+
+  matchWildcard
+    = identStart identChar* "=" "**"  -- recursive
+    | identStart identChar*           -- single
+
+  pathIdent = (letter | digit | "_" | "-" | ".")+
+
+  // === Expressions ===
+
+  Expr = Ternary
+
+  Ternary
+    = LogicalOr "?" Ternary ":" Ternary  -- ternary
+    | LogicalOr
+
+  LogicalOr
+    = LogicalOr "||" LogicalAnd  -- or
+    | LogicalAnd
+
+  LogicalAnd
+    = LogicalAnd "&&" InIsExpr  -- and
+    | InIsExpr
+
+  InIsExpr
+    = Equality in Equality   -- in
+    | Equality is typeName   -- is
+    | Equality
+
+  in = "in" ~identChar
+  is = "is" ~identChar
+
+  Equality
+    = Equality "==" Comparison  -- eq
+    | Equality "!=" Comparison  -- neq
+    | Comparison
+
+  Comparison
+    = Comparison ">=" Additive  -- gte
+    | Comparison "<=" Additive  -- lte
+    | Comparison ">" Additive   -- gt
+    | Comparison "<" Additive   -- lt
+    | Additive
+
+  Additive
+    = Additive "+" Multiplicative  -- add
+    | Additive "-" Multiplicative  -- sub
+    | Multiplicative
+
+  Multiplicative
+    = Multiplicative "*" UnaryExpr  -- mul
+    | Multiplicative "/" UnaryExpr  -- div
+    | Multiplicative "%" UnaryExpr  -- mod
+    | UnaryExpr
+
+  UnaryExpr
+    = "!" UnaryExpr  -- not
+    | "-" UnaryExpr  -- neg
+    | PostfixExpr
+
+  PostfixExpr
+    = PostfixExpr "." memberName "(" ListOf<Expr, ","> ")"  -- methodCall
+    | PostfixExpr "." memberName                             -- memberAccess
+    | PostfixExpr "[" Expr ":" Expr "]"                      -- sliceAccess
+    | PostfixExpr "[" Expr "]"                               -- bracketAccess
+    | Primary
+
+  memberName = identStart identChar*
+
+  Primary
+    = "(" Expr ")"       -- paren
+    | PathLiteral        -- path
+    | ListLiteral        -- list
+    | MapLiteral         -- map
+    | ident "(" ListOf<Expr, ","> ")"  -- functionCall
+    | literal
+    | ident
+
+  // === Path literals ===
+
+  PathLiteral = "/" PathLitSegment ("/" PathLitSegment)*
+
+  PathLitSegment
+    = "$(" Expr ")"    -- interpolation
+    | "{" ident "}"    -- captureRef
+    | pathIdent        -- literal
+
+  // === Literals ===
+
+  literal
+    = number
+    | string
+    | bool
+    | null
+
+  number
+    = digit+ "." digit+  -- float
+    | digit+              -- int
+
+  string
+    = "'" singleStringChar* "'"    -- single
+    | "\\"" doubleStringChar* "\\""  -- double
+
+  singleStringChar
+    = "\\\\" stringEscapeChar  -- escape
+    | ~"\\\\" ~"'" any         -- char
+
+  doubleStringChar
+    = "\\\\" stringEscapeChar  -- escape
+    | ~"\\\\" ~"\\"" any        -- char
+
+  // Valid escape characters following a backslash. Anything else is rejected
+  // at parse time to match production semantics — production Firestore Rules
+  // raises a syntax error on unknown escapes (e.g. \`\\d\`, \`\\.\`). Keeping the
+  // sim strict here prevents over-permissive acceptance that masks model
+  // output that would crash at deploy.
+  stringEscapeChar = "\\\\" | "'" | "\\"" | "n" | "r" | "t" | "/"
+
+  ListLiteral = "[" ListOf<Expr, ","> ","? "]"
+
+  MapLiteral = "{" ListOf<MapEntry, ","> ","? "}"
+
+  MapEntry = (string | ident) ":" Expr
+
+  bool
+    = "true" ~identChar   -- true
+    | "false" ~identChar  -- false
+
+  null = "null" ~identChar
+
+  typeName
+    = "string" ~identChar
+    | "int" ~identChar
+    | "float" ~identChar
+    | "number" ~identChar
+    | "bool" ~identChar
+    | "list" ~identChar
+    | "map" ~identChar
+    | "timestamp" ~identChar
+    | "path" ~identChar
+    | "bytes" ~identChar
+    | "duration" ~identChar
+    | "latlng" ~identChar
+    | "reference" ~identChar
+
+  ident = ~keyword identStart identChar*
+
+  keyword
+    = ("true" | "false" | "null" | "in" | "is" | "if" | "return" | "let") ~identChar
+
+  identStart = letter | "_"
+
+  identChar = alnum | "_"
+
+  // === Whitespace and comments ===
+
+  space += comment
+
+  comment
+    = "//" (~"\\n" any)* &("\\n" | end)  -- singleLine
+    | "/*" (~"*/" any)* "*/"            -- multiLine
+}
+`;
+//# sourceMappingURL=FirestoreRules.ohm.generated.js.map

package/dist/rules/grammar/FirestoreRules.ohm.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirestoreRules.ohm.generated.js","sourceRoot":"","sources":["../../../src/rules/grammar/FirestoreRules.ohm.generated.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,+CAA+C;AAC/C,6BAA6B;AAE7B,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqOzC,CAAC"}

package/dist/rules/grammar/FirestoreValidator.d.ts

@@ -0,0 +1,10 @@
+import type { FirestoreRules } from './FirestoreAST.js';
+export interface ValidationFinding {
+    code: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    path: string;
+    operation?: string;
+    message: string;
+}
+export declare function validateFirestoreRules(ast: FirestoreRules): ValidationFinding[];
+//# sourceMappingURL=FirestoreValidator.d.ts.map

package/dist/rules/grammar/FirestoreValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirestoreValidator.d.ts","sourceRoot":"","sources":["../../../src/rules/grammar/FirestoreValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,cAAc,GAAG,iBAAiB,EAAE,CAwB/E"}