@nubase/backend 0.1.35 → 0.1.38

package/dist/index.mjs

@@ -100,11 +100,14 @@ function createAuthHandlers(options) {
 
 // src/typed-handlers.ts
 var HttpError = class extends Error {
-  constructor(statusCode, message) {
+  constructor(statusCode, message, payload) {
     super(message);
     this.statusCode = statusCode;
+    this.payload = payload;
     this.name = "HttpError";
   }
+  statusCode;
+  payload;
 };
 function createTypedHandler(schemaOrEndpoint, handler) {
   return createTypedHandlerInternal(schemaOrEndpoint, handler);
@@ -184,7 +187,8 @@ function createTypedHandlerInternal(schema, handler, options) {
       if (error instanceof HttpError) {
         return c.json(
           {
-            error: error.message
+            error: error.message,
+            ...error.payload ?? {}
           },
           error.statusCode
         );
@@ -238,6 +242,846 @@ function createHandlerFactory(config) {
   };
 }
 
+// src/nql/bindings.ts
+function createNqlBindings() {
+  return (schema, mapping) => {
+    for (const key of Object.keys(mapping)) {
+      if (!(key in schema._shape)) {
+        throw new Error(
+          `createNqlBindings: field '${key}' is not in the schema shape`
+        );
+      }
+    }
+    return mapping;
+  };
+}
+
+// src/nql/compiler.ts
+function compileToExpression(node, eb, options) {
+  const ctx = {
+    eb,
+    resolveColumn: (field) => {
+      const column = options.fields[field];
+      if (column === void 0) {
+        throw new Error(
+          `NQL compile bug: no binding for schema field '${field}'`
+        );
+      }
+      return column;
+    }
+  };
+  return visit(node, ctx);
+}
+function visit(node, ctx) {
+  switch (node.type) {
+    case "logical":
+      return visitLogical(node, ctx);
+    case "comparison":
+      return visitComparison(node, ctx);
+    case "nullCheck":
+      return visitNullCheck(node, ctx);
+    case "in":
+      return visitIn(node, ctx);
+  }
+}
+function visitLogical(node, ctx) {
+  const children = node.children.map((c) => visit(c, ctx));
+  if (node.op === "AND") return ctx.eb.and(children);
+  if (node.op === "OR") return ctx.eb.or(children);
+  return ctx.eb.not(children[0]);
+}
+function visitComparison(node, ctx) {
+  const col = ctx.resolveColumn(node.field.name);
+  const { op } = node;
+  const baseType = node.field.baseType;
+  const rawValue = literalValue(node.value);
+  if (baseType === "string") {
+    const str = rawValue;
+    switch (op) {
+      case "=":
+        return ctx.eb(col, "ilike", escapeLike(str));
+      case "!=":
+        return ctx.eb(col, "not ilike", escapeLike(str));
+      case "CONTAINS":
+        return ctx.eb(col, "ilike", `%${escapeLike(str)}%`);
+      case "STARTS_WITH":
+        return ctx.eb(col, "ilike", `${escapeLike(str)}%`);
+      case "ENDS_WITH":
+        return ctx.eb(col, "ilike", `%${escapeLike(str)}`);
+    }
+  }
+  switch (op) {
+    case "=":
+      return ctx.eb(col, "=", rawValue);
+    case "!=":
+      return ctx.eb(col, "!=", rawValue);
+    case "<":
+      return ctx.eb(col, "<", rawValue);
+    case "<=":
+      return ctx.eb(col, "<=", rawValue);
+    case ">":
+      return ctx.eb(col, ">", rawValue);
+    case ">=":
+      return ctx.eb(col, ">=", rawValue);
+    default:
+      throw new Error(
+        `NQL compile bug: operator '${op}' not expected on ${baseType}`
+      );
+  }
+}
+function visitNullCheck(node, ctx) {
+  const col = ctx.resolveColumn(node.field.name);
+  return ctx.eb(col, node.negated ? "is not" : "is", null);
+}
+function visitIn(node, ctx) {
+  const col = ctx.resolveColumn(node.field.name);
+  const values = node.values.map(literalValue);
+  return ctx.eb(col, node.negated ? "not in" : "in", values);
+}
+function literalValue(literal) {
+  switch (literal.kind) {
+    case "string":
+      return literal.value;
+    case "number":
+      return literal.value;
+    case "boolean":
+      return literal.value;
+    case "null":
+      return null;
+  }
+}
+function escapeLike(s) {
+  return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+
+// src/nql/parser.ts
+var COMPARISON_OP_BY_KIND = {
+  Eq: "=",
+  NotEq: "!=",
+  Lt: "<",
+  LtEq: "<=",
+  Gt: ">",
+  GtEq: ">=",
+  Contains: "CONTAINS",
+  StartsWith: "STARTS_WITH",
+  EndsWith: "ENDS_WITH"
+};
+function parse(tokens) {
+  const parser = new Parser(tokens);
+  try {
+    const node = parser.parseExpression();
+    parser.expect("Eof", "Expected end of input");
+    return { ok: true, value: node };
+  } catch (e) {
+    if (e instanceof ParseError) {
+      return {
+        ok: false,
+        error: {
+          code: "PARSE",
+          message: e.message,
+          line: e.span.line,
+          column: e.span.column,
+          length: e.span.length
+        }
+      };
+    }
+    throw e;
+  }
+}
+var ParseError = class extends Error {
+  constructor(message, span) {
+    super(message);
+    this.span = span;
+    this.name = "ParseError";
+  }
+  span;
+};
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  pos = 0;
+  parseExpression() {
+    return this.parseOr();
+  }
+  // or_expr := and_expr ( OR and_expr )*
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.peek().kind === "Or") {
+      this.advance();
+      const right = this.parseAnd();
+      left = makeLogical("OR", [left, right]);
+    }
+    return left;
+  }
+  // and_expr := not_expr ( AND not_expr )*
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.peek().kind === "And") {
+      this.advance();
+      const right = this.parseNot();
+      left = makeLogical("AND", [left, right]);
+    }
+    return left;
+  }
+  // not_expr := NOT not_expr | primary
+  parseNot() {
+    if (this.peek().kind === "Not") {
+      const notTok = this.advance();
+      const inner = this.parseNot();
+      return {
+        type: "logical",
+        op: "NOT",
+        children: [inner],
+        span: mergeSpans(notTok.span, inner.span)
+      };
+    }
+    return this.parsePrimary();
+  }
+  // primary := "(" expression ")" | comparison
+  parsePrimary() {
+    const tok = this.peek();
+    if (tok.kind === "LParen") {
+      this.advance();
+      const inner = this.parseExpression();
+      this.expect("RParen", "Expected closing ')'");
+      return inner;
+    }
+    return this.parseComparison();
+  }
+  // comparison := identifier comparison_op literal
+  //             | identifier (IN | NOT IN) "(" literal ("," literal)* ")"
+  //             | identifier IS [NOT] NULL
+  parseComparison() {
+    const identTok = this.peek();
+    if (identTok.kind !== "Identifier") {
+      throw new ParseError(
+        `Expected field name, got ${describeToken(identTok)}`,
+        identTok.span
+      );
+    }
+    this.advance();
+    const field = { raw: identTok.text, span: identTok.span };
+    const opTok = this.peek();
+    if (opTok.kind === "Is") {
+      this.advance();
+      let negated = false;
+      if (this.peek().kind === "Not") {
+        this.advance();
+        negated = true;
+      }
+      const nullTok = this.peek();
+      if (nullTok.kind !== "Null") {
+        throw new ParseError(
+          `Expected NULL after ${negated ? "IS NOT" : "IS"}, got ${describeToken(nullTok)}`,
+          nullTok.span
+        );
+      }
+      this.advance();
+      return {
+        type: "nullCheck",
+        field,
+        negated,
+        span: mergeSpans(identTok.span, nullTok.span)
+      };
+    }
+    if (opTok.kind === "In") {
+      this.advance();
+      const { values, endSpan } = this.parseLiteralList();
+      return {
+        type: "in",
+        field,
+        negated: false,
+        values,
+        span: mergeSpans(identTok.span, endSpan)
+      };
+    }
+    if (opTok.kind === "Not") {
+      this.advance();
+      const inTok = this.peek();
+      if (inTok.kind !== "In") {
+        throw new ParseError(
+          `Expected IN after NOT, got ${describeToken(inTok)}`,
+          inTok.span
+        );
+      }
+      this.advance();
+      const { values, endSpan } = this.parseLiteralList();
+      return {
+        type: "in",
+        field,
+        negated: true,
+        values,
+        span: mergeSpans(identTok.span, endSpan)
+      };
+    }
+    const op = COMPARISON_OP_BY_KIND[opTok.kind];
+    if (!op) {
+      throw new ParseError(
+        `Expected comparison operator after '${identTok.text}', got ${describeToken(opTok)}`,
+        opTok.span
+      );
+    }
+    this.advance();
+    const literal = this.parseLiteral();
+    return {
+      type: "comparison",
+      field,
+      op,
+      value: literal,
+      span: mergeSpans(identTok.span, literal.span)
+    };
+  }
+  // "(" literal ("," literal)* ")"
+  parseLiteralList() {
+    this.expect("LParen", "Expected '(' after IN");
+    const values = [];
+    if (this.peek().kind === "RParen") {
+      throw new ParseError("IN list cannot be empty", this.peek().span);
+    }
+    values.push(this.parseLiteral());
+    while (this.peek().kind === "Comma") {
+      this.advance();
+      values.push(this.parseLiteral());
+    }
+    const rparen = this.expect("RParen", "Expected ')' or ',' in IN list");
+    return { values, endSpan: rparen.span };
+  }
+  parseLiteral() {
+    const tok = this.peek();
+    switch (tok.kind) {
+      case "String":
+        this.advance();
+        return {
+          kind: "string",
+          value: tok.stringValue ?? "",
+          span: tok.span
+        };
+      case "Number":
+        this.advance();
+        return {
+          kind: "number",
+          value: tok.numberValue ?? 0,
+          span: tok.span
+        };
+      case "True":
+        this.advance();
+        return { kind: "boolean", value: true, span: tok.span };
+      case "False":
+        this.advance();
+        return { kind: "boolean", value: false, span: tok.span };
+      case "Null":
+        this.advance();
+        return { kind: "null", span: tok.span };
+      default:
+        throw new ParseError(
+          `Expected literal value, got ${describeToken(tok)}`,
+          tok.span
+        );
+    }
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    const tok = this.tokens[this.pos];
+    if (tok.kind !== "Eof") this.pos += 1;
+    return tok;
+  }
+  expect(kind, message) {
+    const tok = this.peek();
+    if (tok.kind !== kind) {
+      throw new ParseError(`${message}, got ${describeToken(tok)}`, tok.span);
+    }
+    return this.advance();
+  }
+};
+function makeLogical(op, children) {
+  return {
+    type: "logical",
+    op,
+    children,
+    span: mergeSpans(children[0].span, children[1].span)
+  };
+}
+function mergeSpans(a, b) {
+  const start = a.offset <= b.offset ? a : b;
+  const endSpan = a.offset + a.length >= b.offset + b.length ? a : b;
+  const endOffset = endSpan.offset + endSpan.length;
+  return {
+    line: start.line,
+    column: start.column,
+    offset: start.offset,
+    length: endOffset - start.offset
+  };
+}
+function describeToken(tok) {
+  if (tok.kind === "Eof") return "end of input";
+  if (tok.text) return `'${tok.text}'`;
+  return tok.kind;
+}
+
+// src/nql/tokenizer.ts
+var KEYWORDS = {
+  AND: "And",
+  OR: "Or",
+  NOT: "Not",
+  IS: "Is",
+  IN: "In",
+  TRUE: "True",
+  FALSE: "False",
+  NULL: "Null",
+  CONTAINS: "Contains",
+  STARTS_WITH: "StartsWith",
+  ENDS_WITH: "EndsWith"
+};
+function tokenize(source) {
+  const tokens = [];
+  let offset = 0;
+  let line = 1;
+  let column = 1;
+  const makeSpan = (startOffset, startLine, startColumn) => ({
+    line: startLine,
+    column: startColumn,
+    offset: startOffset,
+    length: offset - startOffset
+  });
+  const err = (message, atLine, atColumn, length = 1) => ({
+    ok: false,
+    error: {
+      code: "TOKENIZE",
+      message,
+      line: atLine,
+      column: atColumn,
+      length
+    }
+  });
+  const advance = (ch) => {
+    offset += 1;
+    if (ch === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  };
+  while (offset < source.length) {
+    const ch = source[offset];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      advance(ch);
+      continue;
+    }
+    const startOffset = offset;
+    const startLine = line;
+    const startColumn = column;
+    if (ch === "(") {
+      advance(ch);
+      tokens.push({
+        kind: "LParen",
+        span: makeSpan(startOffset, startLine, startColumn),
+        text: "("
+      });
+      continue;
+    }
+    if (ch === ")") {
+      advance(ch);
+      tokens.push({
+        kind: "RParen",
+        span: makeSpan(startOffset, startLine, startColumn),
+        text: ")"
+      });
+      continue;
+    }
+    if (ch === ",") {
+      advance(ch);
+      tokens.push({
+        kind: "Comma",
+        span: makeSpan(startOffset, startLine, startColumn),
+        text: ","
+      });
+      continue;
+    }
+    if (ch === "=") {
+      advance(ch);
+      tokens.push({
+        kind: "Eq",
+        span: makeSpan(startOffset, startLine, startColumn),
+        text: "="
+      });
+      continue;
+    }
+    if (ch === "!") {
+      const next = source[offset + 1];
+      if (next === "=") {
+        advance(ch);
+        advance(next);
+        tokens.push({
+          kind: "NotEq",
+          span: makeSpan(startOffset, startLine, startColumn),
+          text: "!="
+        });
+        continue;
+      }
+      return err(`Unexpected character '!'`, startLine, startColumn);
+    }
+    if (ch === "<") {
+      const next = source[offset + 1];
+      if (next === "=") {
+        advance(ch);
+        advance(next);
+        tokens.push({
+          kind: "LtEq",
+          span: makeSpan(startOffset, startLine, startColumn),
+          text: "<="
+        });
+      } else {
+        advance(ch);
+        tokens.push({
+          kind: "Lt",
+          span: makeSpan(startOffset, startLine, startColumn),
+          text: "<"
+        });
+      }
+      continue;
+    }
+    if (ch === ">") {
+      const next = source[offset + 1];
+      if (next === "=") {
+        advance(ch);
+        advance(next);
+        tokens.push({
+          kind: "GtEq",
+          span: makeSpan(startOffset, startLine, startColumn),
+          text: ">="
+        });
+      } else {
+        advance(ch);
+        tokens.push({
+          kind: "Gt",
+          span: makeSpan(startOffset, startLine, startColumn),
+          text: ">"
+        });
+      }
+      continue;
+    }
+    if (ch === '"') {
+      advance(ch);
+      let value = "";
+      let closed = false;
+      while (offset < source.length) {
+        const c = source[offset];
+        if (c === "\\") {
+          const next = source[offset + 1];
+          if (next === '"' || next === "\\") {
+            value += next;
+            advance(c);
+            advance(next);
+            continue;
+          }
+          return err(
+            `Invalid escape sequence '\\${next ?? ""}'`,
+            line,
+            column,
+            2
+          );
+        }
+        if (c === '"') {
+          advance(c);
+          closed = true;
+          break;
+        }
+        if (c === "\n") {
+          return err("Unterminated string literal", startLine, startColumn);
+        }
+        value += c;
+        advance(c);
+      }
+      if (!closed) {
+        return err("Unterminated string literal", startLine, startColumn);
+      }
+      const span = makeSpan(startOffset, startLine, startColumn);
+      tokens.push({
+        kind: "String",
+        span,
+        text: source.slice(startOffset, offset),
+        stringValue: value
+      });
+      continue;
+    }
+    if (isDigit(ch) || ch === "-" && isDigit(source[offset + 1] ?? "")) {
+      if (ch === "-") advance(ch);
+      while (offset < source.length && isDigit(source[offset])) {
+        advance(source[offset]);
+      }
+      if (source[offset] === ".") {
+        const afterDot = source[offset + 1];
+        if (!afterDot || !isDigit(afterDot)) {
+          return err("Expected digit after decimal point", line, column);
+        }
+        advance(".");
+        while (offset < source.length && isDigit(source[offset])) {
+          advance(source[offset]);
+        }
+      }
+      const text = source.slice(startOffset, offset);
+      const parsed = Number(text);
+      if (!Number.isFinite(parsed)) {
+        return err(
+          `Invalid number '${text}'`,
+          startLine,
+          startColumn,
+          text.length
+        );
+      }
+      tokens.push({
+        kind: "Number",
+        span: makeSpan(startOffset, startLine, startColumn),
+        text,
+        numberValue: parsed
+      });
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      while (offset < source.length && isIdentPart(source[offset])) {
+        advance(source[offset]);
+      }
+      const text = source.slice(startOffset, offset);
+      const upper = text.toUpperCase();
+      const span = makeSpan(startOffset, startLine, startColumn);
+      const keywordKind = KEYWORDS[upper];
+      if (keywordKind) {
+        tokens.push({ kind: keywordKind, span, text });
+      } else {
+        tokens.push({ kind: "Identifier", span, text });
+      }
+      continue;
+    }
+    return err(`Unexpected character '${ch}'`, startLine, startColumn);
+  }
+  tokens.push({
+    kind: "Eof",
+    span: { line, column, offset, length: 0 },
+    text: ""
+  });
+  return { ok: true, value: tokens };
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function isIdentStart(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+}
+function isIdentPart(ch) {
+  return isIdentStart(ch) || isDigit(ch);
+}
+
+// src/nql/validator.ts
+import {
+  OptionalSchema
+} from "@nubase/core";
+var ALLOWED_OPS_BY_TYPE = {
+  string: /* @__PURE__ */ new Set([
+    "=",
+    "!=",
+    "CONTAINS",
+    "STARTS_WITH",
+    "ENDS_WITH"
+  ]),
+  number: /* @__PURE__ */ new Set(["=", "!=", "<", "<=", ">", ">="]),
+  boolean: /* @__PURE__ */ new Set(["=", "!="])
+};
+function validate(node, schema, options = {}) {
+  const fields = buildFieldMap(schema, options.allowFields);
+  try {
+    return { ok: true, value: visit2(node, fields) };
+  } catch (e) {
+    if (e instanceof ValidateError) {
+      return {
+        ok: false,
+        error: {
+          code: "VALIDATE",
+          message: e.message,
+          line: e.span.line,
+          column: e.span.column,
+          length: e.span.length
+        }
+      };
+    }
+    throw e;
+  }
+}
+var ValidateError = class extends Error {
+  constructor(message, span) {
+    super(message);
+    this.span = span;
+    this.name = "ValidateError";
+  }
+  span;
+};
+function buildFieldMap(schema, allowFields) {
+  const map = /* @__PURE__ */ new Map();
+  const allowSet = allowFields ? new Set(allowFields.map((f) => f.toLowerCase())) : void 0;
+  for (const key of Object.keys(schema._shape)) {
+    if (allowSet && !allowSet.has(key.toLowerCase())) continue;
+    const fieldSchema = schema._shape[key];
+    const optional = fieldSchema instanceof OptionalSchema;
+    const baseTypeRaw = optional ? fieldSchema.baseType : fieldSchema.type;
+    map.set(key.toLowerCase(), {
+      canonical: key,
+      baseType: coerceBaseType(baseTypeRaw),
+      optional,
+      baseTypeRaw
+    });
+  }
+  return map;
+}
+function coerceBaseType(raw) {
+  if (raw === "string" || raw === "number" || raw === "boolean") {
+    return raw;
+  }
+  return null;
+}
+function visit2(node, fields) {
+  switch (node.type) {
+    case "logical":
+      return visitLogical2(node, fields);
+    case "comparison":
+      return visitComparison2(node, fields);
+    case "nullCheck":
+      return visitNullCheck2(node, fields);
+    case "in":
+      return visitIn2(node, fields);
+  }
+}
+function visitLogical2(node, fields) {
+  return {
+    type: "logical",
+    op: node.op,
+    children: node.children.map((c) => visit2(c, fields)),
+    span: node.span
+  };
+}
+function visitComparison2(node, fields) {
+  const field = resolveField(node.field, fields);
+  ensureSupportedBaseType(field, node.field.span);
+  ensureOperatorAllowed(field.baseType, node.op, node.field.span);
+  ensureLiteralMatchesField(
+    node.value,
+    field.baseType,
+    field.canonical,
+    /*allowNull*/
+    false
+  );
+  return {
+    type: "comparison",
+    field: makeFieldRef(field, node.field.span),
+    op: node.op,
+    value: node.value,
+    span: node.span
+  };
+}
+function visitNullCheck2(node, fields) {
+  const field = resolveField(node.field, fields);
+  ensureSupportedBaseType(field, node.field.span);
+  if (!field.optional) {
+    throw new ValidateError(
+      `Field '${field.canonical}' is required and cannot be null`,
+      node.span
+    );
+  }
+  return {
+    type: "nullCheck",
+    field: makeFieldRef(field, node.field.span),
+    negated: node.negated,
+    span: node.span
+  };
+}
+function visitIn2(node, fields) {
+  const field = resolveField(node.field, fields);
+  ensureSupportedBaseType(field, node.field.span);
+  for (const value of node.values) {
+    ensureLiteralMatchesField(
+      value,
+      field.baseType,
+      field.canonical,
+      /*allowNull*/
+      false
+    );
+  }
+  return {
+    type: "in",
+    field: makeFieldRef(field, node.field.span),
+    negated: node.negated,
+    values: node.values,
+    span: node.span
+  };
+}
+function resolveField(ref, fields) {
+  const resolved = fields.get(ref.raw.toLowerCase());
+  if (!resolved) {
+    throw new ValidateError(`Unknown field '${ref.raw}'`, ref.span);
+  }
+  return resolved;
+}
+function ensureSupportedBaseType(field, span) {
+  if (field.baseType === null) {
+    throw new ValidateError(
+      `Field '${field.canonical}' of type '${field.baseTypeRaw}' is not queryable`,
+      span
+    );
+  }
+}
+function ensureOperatorAllowed(baseType, op, span) {
+  const allowed = ALLOWED_OPS_BY_TYPE[baseType];
+  if (!allowed.has(op)) {
+    throw new ValidateError(
+      `Operator '${op}' is not supported on ${baseType} fields`,
+      span
+    );
+  }
+}
+function ensureLiteralMatchesField(literal, baseType, fieldName, allowNull) {
+  if (literal.kind === "null") {
+    if (!allowNull) {
+      throw new ValidateError(
+        `Use 'IS NULL' to check for null values on '${fieldName}'`,
+        literal.span
+      );
+    }
+    return;
+  }
+  if (literal.kind !== baseType) {
+    throw new ValidateError(
+      `Field '${fieldName}' expects a ${baseType} value, got ${literal.kind}`,
+      literal.span
+    );
+  }
+}
+function makeFieldRef(field, span) {
+  return {
+    name: field.canonical,
+    baseType: field.baseType,
+    optional: field.optional,
+    span
+  };
+}
+
+// src/nql/compile.ts
+function compileNql(source, schema, options) {
+  const toks = tokenize(source);
+  if (!toks.ok) return { ok: false, error: toks.error };
+  const parsed = parse(toks.value);
+  if (!parsed.ok) return { ok: false, error: parsed.error };
+  const validated = validate(parsed.value, schema, {
+    allowFields: Object.keys(options.fields)
+  });
+  if (!validated.ok) return { ok: false, error: validated.error };
+  const node = validated.value;
+  const applied = (eb) => compileToExpression(node, eb, { fields: options.fields });
+  return { ok: true, value: applied };
+}
+
 // src/utils/cookies.ts
 function parseCookies(cookieHeader) {
   const cookies = {};
@@ -283,10 +1127,12 @@ export {
   AUTH_CONTROLLER_KEY,
   AUTH_USER_KEY,
   HttpError,
+  compileNql,
   createAuthHandlers,
   createAuthMiddleware,
   createHandlerFactory,
   createHttpHandler,
+  createNqlBindings,
   createTypedHandler,
   createTypedRoutes,
   getAuthController,