Update ESLint and Prettier

lib/common/authorizer.ts

@@ -23,13 +23,13 @@ import { evaluate, or } from "./expression";
 export default class Authorizer {
   private permissionSets: PermissionSet[];
   private validatorCache: WeakMap<
-    object,
+    any,
     (mutationType, mutation, any) => boolean
   >;
   private hasAccessCache: Map<string, boolean>;
   private getFilterCache: Map<string, Expression>;
 
-  public constructor(permissionSets) {
+  public constructor(permissionSets: PermissionSet[]) {
     this.permissionSets = permissionSets;
     this.validatorCache = new WeakMap();
     this.hasAccessCache = new Map();
@@ -77,8 +77,8 @@ export default class Authorizer {
   }
 
   public getValidator(
-    resourceType,
-    resource
+    resourceType: string,
+    resource: unknown
   ): (mutationType: string, mutation?: any, args?: any) => boolean {
     if (this.validatorCache.has(resource))
       return this.validatorCache.get(resource);
@@ -108,7 +108,7 @@ export default class Authorizer {
         mutation,
         resourceType,
         object: resource,
-        options: any
+        options: any,
       };
 
       const valueFunction = (paramName): any => {

lib/common/expression-cnf.ts

@@ -65,7 +65,7 @@ function likePatternIncludes(pat1, pat2, idx1 = 0, idx2 = 0): boolean {
 export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
   const ranges = new Map();
   const likePatterns = new Map();
-  map(exp, e => {
+  map(exp, (e) => {
     if (!Array.isArray(e)) return e;
     if (e[0] === "LIKE" || e[0] === "NOT LIKE") {
       if (
@@ -151,7 +151,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
 
     if (to == null) vars.push(`${lhs}:${range[range.length - 1]}--`);
 
-    return vars.map(key => {
+    return vars.map((key) => {
       let f = expressions.get(key);
       if (!f) {
         expressions.set(key, (f = expressions.size + 1));
@@ -172,7 +172,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
         vars.push(`${lhs}:like:${JSON.stringify(p)}`);
     }
 
-    return vars.map(key => {
+    return vars.map((key) => {
       let f = expressions.get(key);
       if (!f) expressions.set(key, (f = expressions.size + 1));
       return f;
@@ -184,11 +184,11 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
   }
 
   const comparisonOperators: ComparisonOperators = {
-    "=": v => [v, true, v, true],
-    ">": v => [v, false, null, null],
-    ">=": v => [v, true, null, null],
-    "<": v => [null, null, v, false],
-    "<=": v => [null, null, v, true]
+    "=": (v) => [v, true, v, true],
+    ">": (v) => [v, false, null, null],
+    ">=": (v) => [v, true, null, null],
+    "<": (v) => [null, null, v, false],
+    "<=": (v) => [null, null, v, true],
   };
 
   function recursive(clause, negate): CNF {
@@ -211,7 +211,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
         JSON.stringify(clause[1]),
         ...comparisonOperators["="](clause[2])
       );
-      if (!negate) return vars.map(x => [0 - x]);
+      if (!negate) return vars.map((x) => [0 - x]);
       else return [vars];
     } else if (op === "IS NULL") {
       const v = getVariable(JSON.stringify(clause[1]), "null");
@@ -227,7 +227,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
           JSON.stringify(clause[1]),
           ...comparisonOperators[op](clause[2])
         );
-        if (negate) return vars.map(x => [0 - x]);
+        if (negate) return vars.map((x) => [0 - x]);
         else return [vars];
       } else if (!Array.isArray(clause[1])) {
         op = { ">": "<", ">=": "<=", "<": ">", "<=": ">=" }[op] || op;
@@ -235,7 +235,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
           JSON.stringify(clause[2]),
           ...comparisonOperators[op](clause[1])
         );
-        if (negate) return vars.map(x => [0 - x]);
+        if (negate) return vars.map((x) => [0 - x]);
         else return [vars];
       } else {
         let lhs = JSON.stringify(clause[1]);
@@ -264,7 +264,7 @@ export function booleanCnf(exp: Expression): { vars: number; clauses: CNF } {
         clause[2],
         clause[3]
       );
-      if (negate) return vars.map(x => [0 - x]);
+      if (negate) return vars.map((x) => [0 - x]);
       else return [vars];
     } else {
       const v = getVariable(JSON.stringify(clause), "");

lib/common/expression-parser.ts

@@ -27,7 +27,7 @@ function interpretEscapes(str): string {
     f: "\f",
     n: "\n",
     r: "\r",
-    t: "\t"
+    t: "\t",
   };
   return str.replace(/\\(u[0-9a-fA-F]{4}|[^u])/, (_, escape) => {
     const type = escape.charAt(0);
@@ -40,7 +40,10 @@ function interpretEscapes(str): string {
   });
 }
 
-export function map(exp, callback): Expression {
+export function map(
+  exp: Expression,
+  callback: (exp: Expression) => Expression
+): Expression {
   if (!Array.isArray(exp)) return callback(exp);
 
   let clone;
@@ -55,7 +58,10 @@ export function map(exp, callback): Expression {
   return callback(clone || exp);
 }
 
-export async function mapAsync(exp, callback): Promise<Expression> {
+export async function mapAsync(
+  exp: Expression,
+  callback: (exp: Expression) => Promise<Expression>
+): Promise<Expression> {
   if (!Array.isArray(exp)) return callback(exp);
 
   let clone;
@@ -70,7 +76,7 @@ export async function mapAsync(exp, callback): Promise<Expression> {
   return callback(clone || exp);
 }
 
-function binaryLeft(operatorsParser, nextParser): parsimmon.Parser<{}> {
+function binaryLeft(operatorsParser, nextParser): parsimmon.Parser<unknown> {
   return parsimmon.seqMap(
     nextParser,
     parsimmon.seq(operatorsParser, nextParser).many(),
@@ -86,7 +92,7 @@ function binaryLeft(operatorsParser, nextParser): parsimmon.Parser<{}> {
 }
 
 const lang = parsimmon.createLanguage({
-  ComparisonOperator: function() {
+  ComparisonOperator: function () {
     return parsimmon
       .alt(
         parsimmon.string(">="),
@@ -98,13 +104,10 @@ const lang = parsimmon.createLanguage({
       )
       .skip(parsimmon.optWhitespace);
   },
-  LikeOperator: function() {
+  LikeOperator: function () {
     return parsimmon
       .alt(
-        parsimmon
-          .regexp(/like/i)
-          .result("LIKE")
-          .desc("LIKE"),
+        parsimmon.regexp(/like/i).result("LIKE").desc("LIKE"),
         parsimmon
           .regexp(/not\s+like/i)
           .result("NOT LIKE")
@@ -113,7 +116,7 @@ const lang = parsimmon.createLanguage({
       .notFollowedBy(parsimmon.regexp(/[a-zA-Z0-9_]/))
       .skip(parsimmon.optWhitespace);
   },
-  IsNullOperator: function() {
+  IsNullOperator: function () {
     return parsimmon
       .alt(
         parsimmon
@@ -128,7 +131,7 @@ const lang = parsimmon.createLanguage({
       .notFollowedBy(parsimmon.regexp(/[a-zA-Z0-9_]/))
       .skip(parsimmon.optWhitespace);
   },
-  NotOperator: function() {
+  NotOperator: function () {
     return parsimmon
       .regexp(/not/i)
       .result("NOT")
@@ -136,7 +139,7 @@ const lang = parsimmon.createLanguage({
       .skip(parsimmon.optWhitespace)
       .desc("NOT");
   },
-  AndOperator: function() {
+  AndOperator: function () {
     return parsimmon
       .regexp(/and/i)
       .result("AND")
@@ -144,7 +147,7 @@ const lang = parsimmon.createLanguage({
       .skip(parsimmon.optWhitespace)
       .desc("AND");
   },
-  OrOperator: function() {
+  OrOperator: function () {
     return parsimmon
       .regexp(/or/i)
       .result("OR")
@@ -152,7 +155,7 @@ const lang = parsimmon.createLanguage({
       .skip(parsimmon.optWhitespace)
       .desc("OR");
   },
-  Parameter: function(r) {
+  Parameter: function (r) {
     return parsimmon
       .alt(
         parsimmon.regexp(/[a-zA-Z0-9_.*-]+/),
@@ -162,48 +165,42 @@ const lang = parsimmon.createLanguage({
         )
       )
       .atLeast(1)
-      .map(x => ["PARAM", x.length > 1 ? ["||"].concat(x) : x[0]])
+      .map((x) => ["PARAM", x.length > 1 ? ["||"].concat(x) : x[0]])
       .skip(parsimmon.optWhitespace)
       .desc("parameter");
   },
-  StringValueSql: function() {
+  StringValueSql: function () {
     return parsimmon
       .regexp(/'([^']*)'/, 1)
       .atLeast(1)
       .skip(parsimmon.optWhitespace)
-      .map(s => s.join("'"))
+      .map((s) => s.join("'"))
       .desc("string");
   },
-  StringValueJs: function() {
+  StringValueJs: function () {
     return parsimmon
       .regexp(/"((?:\\.|.)*?)"/, 1)
       .skip(parsimmon.optWhitespace)
       .map(interpretEscapes)
       .desc("string");
   },
-  NumberValue: function() {
+  NumberValue: function () {
     return parsimmon
       .regexp(/-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/)
       .skip(parsimmon.optWhitespace)
       .map(Number)
       .desc("number");
   },
-  BooleanValue: function() {
+  BooleanValue: function () {
     return parsimmon
       .alt(
-        parsimmon
-          .regexp(/true/i)
-          .result(true)
-          .desc("TRUE"),
-        parsimmon
-          .regexp(/false/i)
-          .result(false)
-          .desc("FALSE")
+        parsimmon.regexp(/true/i).result(true).desc("TRUE"),
+        parsimmon.regexp(/false/i).result(false).desc("FALSE")
       )
       .notFollowedBy(parsimmon.regexp(/[a-zA-Z0-9_]/))
       .skip(parsimmon.optWhitespace);
   },
-  NullValue: function() {
+  NullValue: function () {
     return parsimmon
       .regexp(/null/i)
       .notFollowedBy(parsimmon.regexp(/[a-zA-Z0-9_]/))
@@ -211,7 +208,7 @@ const lang = parsimmon.createLanguage({
       .result(null)
       .desc("NULL");
   },
-  FuncValue: function(r) {
+  FuncValue: function (r) {
     return parsimmon.seqMap(
       parsimmon
         .regexp(/([a-zA-Z0-9_]+)/, 1)
@@ -226,7 +223,7 @@ const lang = parsimmon.createLanguage({
       (f, args) => ["FUNC", f.toUpperCase()].concat(args)
     );
   },
-  Value: function(r) {
+  Value: function (r) {
     return parsimmon.alt(
       r.NullValue,
       r.BooleanValue,
@@ -236,7 +233,7 @@ const lang = parsimmon.createLanguage({
       r.FuncValue
     );
   },
-  ValueExpression: function(r) {
+  ValueExpression: function (r) {
     return binaryLeft(
       parsimmon.string("||").skip(parsimmon.optWhitespace),
       binaryLeft(
@@ -259,7 +256,7 @@ const lang = parsimmon.createLanguage({
       )
     );
   },
-  Comparison: function(r) {
+  Comparison: function (r) {
     return parsimmon.alt(
       parsimmon.seqMap(r.ValueExpression, r.IsNullOperator, (p, o) => [o, p]),
       parsimmon.seqMap(
@@ -289,8 +286,8 @@ const lang = parsimmon.createLanguage({
       )
     );
   },
-  Expression: function(r) {
-    function unary(operatorsParser, nextParser): parsimmon.Parser<{}> {
+  Expression: function (r) {
+    function unary(operatorsParser, nextParser): parsimmon.Parser<unknown> {
       return parsimmon.seq(operatorsParser, nextParser).or(nextParser);
     }
 
@@ -301,7 +298,7 @@ const lang = parsimmon.createLanguage({
         unary(r.NotOperator, r.Comparison.or(r.ValueExpression))
       )
     ).trim(parsimmon.optWhitespace);
-  }
+  },
 });
 
 export function parse(str: string): Expression {
@@ -309,7 +306,7 @@ export function parse(str: string): Expression {
   return lang.Expression.tryParse(str);
 }
 
-export function stringify(exp, level = 0): string {
+export function stringify(exp: Expression, level = 0): string {
   if (!Array.isArray(exp)) return JSON.stringify(exp);
 
   const opLevels = {
@@ -330,7 +327,7 @@ export function stringify(exp, level = 0): string {
     "+": 31,
     "-": 31,
     "*": 32,
-    "/": 32
+    "/": 32,
   };
 
   const op = exp[0].toUpperCase();
@@ -344,7 +341,7 @@ export function stringify(exp, level = 0): string {
     return wrap(
       `${exp[1]}(${exp
         .slice(2)
-        .map(e => stringify(e))
+        .map((e) => stringify(e))
         .join(", ")})`
     );
   } else if (op === "PARAM") {
@@ -354,7 +351,7 @@ export function stringify(exp, level = 0): string {
       return wrap(
         exp[1]
           .slice(1)
-          .map(p => {
+          .map((p) => {
             if (typeof p === "string") return p;
             else return `{${stringify(p)}}`;
           })
@@ -393,7 +390,7 @@ export function stringify(exp, level = 0): string {
   }
 }
 
-export function parseLikePattern(pat, esc): string[] {
+export function parseLikePattern(pat: string, esc: string): string[] {
   const chars = pat.split("");
 
   for (let i = 0; i < chars.length; ++i) {
@@ -408,5 +405,5 @@ export function parseLikePattern(pat, esc): string[] {
       while (chars[i + 1] === "%") chars[++i] = "";
     }
   }
-  return chars.filter(c => c);
+  return chars.filter((c) => c);
 }

lib/common/expression.ts

@@ -24,7 +24,7 @@ import { Expression } from "../types";
 
 const isArray = Array.isArray;
 
-const regExpCache = new WeakMap<object, RegExp>();
+const regExpCache = new WeakMap<any, RegExp>();
 
 const REDUCE_SKIP = {};
 function reduce(exp, callback): Expression {
@@ -44,7 +44,7 @@ function reduce(exp, callback): Expression {
   return exp;
 }
 
-export function likePatternToRegExp(pat, esc = "", flags = ""): RegExp {
+export function likePatternToRegExp(pat: string, esc = "", flags = ""): RegExp {
   const convChars = {
     "-": "\\-",
     "/": "\\/",
@@ -63,11 +63,11 @@ export function likePatternToRegExp(pat, esc = "", flags = ""): RegExp {
     "{": "\\{",
     "}": "\\}",
     "\\%": ".*",
-    "\\_": "."
+    "\\_": ".",
   };
   let chars = parseLikePattern(pat, esc);
   if (!chars.length) return new RegExp("^$", flags);
-  chars = chars.map(c => convChars[c] || c);
+  chars = chars.map((c) => convChars[c] || c);
   chars[0] = chars[0] === ".*" ? "" : "^" + chars[0];
   const l = chars.length - 1;
   chars[l] = [".*", ""].includes(chars[l]) ? "" : chars[l] + "$";
@@ -195,14 +195,24 @@ function evalExp(e: Expression): Expression {
 }
 
 export function evaluate(
-  exp,
-  obj,
+  exp: Expression,
+  obj: Record<string, unknown> | ((exp: string) => Expression),
   now: number,
-  cb?: Function
+  cb?: (exp: Expression) => Expression
 ): string | number | boolean | null;
-export function evaluate(exp, obj?, now?: number, cb?: Function): Expression;
-export function evaluate(exp, obj?, now?: number, cb?: Function): Expression {
-  return map(exp, e => {
+export function evaluate(
+  exp: Expression,
+  obj?: Record<string, unknown> | ((exp: string) => Expression),
+  now?: number,
+  cb?: (exp: Expression) => Expression
+): Expression;
+export function evaluate(
+  exp: Expression,
+  obj?: Record<string, unknown> | ((exp: string) => Expression),
+  now?: number,
+  cb?: (exp: Expression) => Expression
+): Expression {
+  return map(exp, (e) => {
     if (cb) e = cb(e);
     if (!isArray(e)) return e;
 
@@ -233,24 +243,24 @@ export function evaluate(exp, obj?, now?: number, cb?: Function): Expression {
 }
 
 export async function evaluateAsync(
-  exp,
-  obj,
+  exp: Expression,
+  obj: Record<string, unknown>,
   now: number,
-  cb?: Function
+  cb?: (exp: Expression) => Promise<Expression>
 ): Promise<string | number | boolean | null>;
 export async function evaluateAsync(
-  exp,
-  obj?,
+  exp: Expression,
+  obj?: Record<string, unknown>,
   now?: number,
-  cb?: Function
+  cb?: (exp: Expression) => Promise<Expression>
 ): Promise<Expression>;
 export async function evaluateAsync(
-  exp,
-  obj?,
+  exp: Expression,
+  obj?: Record<string, unknown>,
   now?: number,
-  cb?: Function
+  cb?: (exp: Expression) => Promise<Expression>
 ): Promise<Expression> {
-  return mapAsync(exp, async e => {
+  return mapAsync(exp, async (e) => {
     if (cb) e = await cb(e);
     if (!isArray(e)) return e;
 
@@ -269,8 +279,8 @@ export async function evaluateAsync(
       if (obj && !isArray(e[1])) {
         let v = obj[e[1]];
         if (v == null) return null;
-        if (typeof v === "object") v = v.value ? v.value[0] : null;
-        return v;
+        if (typeof v === "object") v = v["value"] ? v["value"][0] : null;
+        return v as Expression;
       }
     }
     return evalExp(e);
@@ -307,21 +317,21 @@ export function or(exp1: Expression, exp2: Expression): Expression {
   return res;
 }
 
-export function not(exp): Expression {
+export function not(exp: Expression): Expression {
   if (isArray(exp) && exp[0] === "NOT") return exp[1];
   return ["NOT", exp];
 }
 
-export function subset(exp1, exp2): boolean {
+export function subset(exp1: Expression, exp2: Expression): boolean {
   const e = evaluate(["NOT", ["OR", ["NOT", exp1], exp2]]);
   if (!isArray(e)) return !e;
   const { vars, clauses } = booleanCnf(e);
   return !naiveDpll(clauses, vars);
 }
 
-export function extractParams(exp): Expression[] {
+export function extractParams(exp: Expression): Expression[] {
   const params = new Set<Expression>();
-  map(exp, e => {
+  map(exp, (e) => {
     if (isArray(e) && e[0] === "PARAM") params.add(e[1]);
     return e;
   });

lib/common/memoize.ts

@@ -39,7 +39,7 @@ function getKey(obj): string {
   return k;
 }
 
-export default function memoize<T extends Function>(func: T): T {
+export default function memoize<T extends (...args: any[]) => any>(func: T): T {
   const funcKey = getKey(func);
   return ((...args) => {
     const key = JSON.stringify(args.map(getKey)) + funcKey;

lib/common/path-set.ts

@@ -73,8 +73,8 @@ export default class PathSet {
 
   public find(
     path: Path,
-    superset: boolean = false,
-    subset: boolean = false,
+    superset = false,
+    subset = false,
     depth: number = path.length
   ): Path[] {
     if (path.alias) throw new Error("PathSet does not support aliased paths");
@@ -106,24 +106,24 @@ export default class PathSet {
       if (!fragmentIndexSet1) {
         if (!fragmentIndexSet2) return [];
         if (!res) res = [...fragmentIndexSet2];
-        else res = res.filter(r => fragmentIndexSet2.has(r));
+        else res = res.filter((r) => fragmentIndexSet2.has(r));
       } else if (!fragmentIndexSet2) {
         if (!res) res = [...fragmentIndexSet1];
-        else res = res.filter(r => fragmentIndexSet1.has(r));
+        else res = res.filter((r) => fragmentIndexSet1.has(r));
       } else {
         if (!res) {
           res = [...fragmentIndexSet1, ...fragmentIndexSet2];
         } else {
           res = res.filter(
-            r => fragmentIndexSet1.has(r) || fragmentIndexSet2.has(r)
+            (r) => fragmentIndexSet1.has(r) || fragmentIndexSet2.has(r)
           );
         }
       }
       if (!res.length) return res;
     }
 
-    if (!res) res = [].concat(...lengthIndex.map(a => [...a]));
-    else res = res.filter(r => lengthIndex.some(a => a.has(r)));
+    if (!res) res = [].concat(...lengthIndex.map((a) => [...a]));
+    else res = res.filter((r) => lengthIndex.some((a) => a.has(r)));
 
     return res;
   }

lib/common/path.ts

@@ -119,7 +119,7 @@ export default class Path {
       if (Array.isArray(s)) {
         alias |= 1 << i;
         const parts = s.map(
-          al => `${al[0].toString()}:${JSON.stringify(al[1])}`
+          (al) => `${al[0].toString()}:${JSON.stringify(al[1])}`
         );
         return `[${parts.join(",")}]`;
       } else if (s === "*") {
@@ -160,7 +160,7 @@ export default class Path {
     return this._string;
   }
 
-  public slice(start: number = 0, end: number = this.segments.length): Path {
+  public slice(start = 0, end: number = this.segments.length): Path {
     if (start < 0) start = Math.max(0, this.segments.length + start);
     if (end < 0) end = Math.max(0, this.segments.length + end);
 
@@ -212,7 +212,7 @@ export default class Path {
 
   public stripAlias(): Path {
     if (!this.alias) return this;
-    const segments = this.segments.map(s => (Array.isArray(s) ? "*" : s));
+    const segments = this.segments.map((s) => (Array.isArray(s) ? "*" : s));
     const str = segments.join(".");
 
     let path = cache1.get(str);

lib/common/sat-solver.ts

@@ -168,7 +168,7 @@ function unitPropagate(clauses, varVals): number[] | 1 | -1 {
   return derivedVars;
 }
 
-export function naiveDpll(clauses, maxvarnr): boolean {
+export function naiveDpll(clauses: unknown[], maxvarnr: number): boolean {
   // variable values are 0 if not set, 1 if positive, -1 if negative
   const varVals = new Int32Array(maxvarnr + 1);
   return satisfiableAt(clauses, varVals, 0, 0);