ponder 0.9.4-debug.1 → 0.9.5-debug.1

package/dist/index.js

@@ -1,2219 +0,0 @@
-import {
-  deserialize,
-  getMetadataStore,
-  never,
-  serialize
-} from "./chunk-DZFRP3KH.js";
-import {
-  promiseWithResolvers
-} from "./chunk-MJKRYIBO.js";
-import {
-  bigint,
-  hex,
-  onchainEnum,
-  onchainTable,
-  primaryKey
-} from "./chunk-K2TLRLX3.js";
-
-// src/config/index.ts
-var createConfig = (config) => config;
-
-// src/config/address.ts
-var factory = (factory2) => factory2;
-
-// src/index.ts
-import {
-  mergeAbis,
-  loadBalance,
-  rateLimit,
-  replaceBigInts
-} from "@ponder/utils";
-
-// src/client/index.ts
-import { pgTable } from "drizzle-orm/pg-core";
-import { createMiddleware } from "hono/factory";
-import { streamSSE } from "hono/streaming";
-import superjson from "superjson";
-
-// src/client/validate.ts
-var getNodeType = (node) => Object.keys(node)[0];
-var ALLOW_CACHE = /* @__PURE__ */ new Map();
-var validateQuery = async (sql2) => {
-  const Parser = await import(
-    /* webpackIgnore: true */
-    "pg-query-emscripten"
-  );
-  const crypto = await import(
-    /* webpackIgnore: true */
-    "node:crypto"
-  );
-  const hash = crypto.createHash("sha256").update(sql2).digest("hex").slice(0, 10);
-  if (ALLOW_CACHE.has(hash)) {
-    const result = ALLOW_CACHE.get(hash);
-    ALLOW_CACHE.delete(hash);
-    ALLOW_CACHE.set(hash, result);
-    if (result)
-      return;
-    throw new Error("Invalid query");
-  } else {
-    ALLOW_CACHE.set(hash, false);
-  }
-  const { parse } = await Parser.default();
-  const parseResult = parse(sql2);
-  if (parseResult.error !== null) {
-    throw new Error(parseResult.error);
-  }
-  if (parseResult.parse_tree.stmts.length === 0) {
-    throw new Error("Invalid query");
-  }
-  if (parseResult.parse_tree.stmts.length > 1) {
-    throw new Error("Multiple statements not supported");
-  }
-  const stmt = parseResult.parse_tree.stmts[0];
-  if (stmt.stmt === void 0) {
-    throw new Error("Invalid query");
-  }
-  const validate = (node) => {
-    if (ALLOW_LIST.has(getNodeType(node)) === false) {
-      throw new Error(`${getNodeType(node)} not supported`);
-    }
-    ALLOW_LIST.get(getNodeType(node)).validate?.(node[getNodeType(node)]);
-    for (const child of ALLOW_LIST.get(getNodeType(node)).children(
-      // @ts-ignore
-      node[getNodeType(node)]
-    )) {
-      validate(child);
-    }
-  };
-  validate(stmt.stmt);
-  ALLOW_CACHE.set(hash, true);
-  if (ALLOW_CACHE.size > 1e6) {
-    const firstKey = ALLOW_CACHE.keys().next().value;
-    if (firstKey)
-      ALLOW_CACHE.delete(firstKey);
-  }
-};
-var INTEGER_VALIDATOR = {
-  node: "Integer",
-  children: () => []
-};
-var FLOAT_VALIDATOR = {
-  node: "Float",
-  children: () => []
-};
-var BOOLEAN_VALIDATOR = {
-  node: "Boolean",
-  children: () => []
-};
-var STRING_VALIDATOR = {
-  node: "String",
-  children: () => []
-};
-var BIT_STRING_VALIDATOR = {
-  node: "BitString",
-  children: () => []
-};
-var LIST_VALIDATOR = {
-  node: "List",
-  children: (node) => [...node.items ?? []]
-};
-var OID_LIST_VALIDATOR = {
-  node: "OidList",
-  children: (node) => [...node.items ?? []]
-};
-var INT_LIST_VALIDATOR = {
-  node: "IntList",
-  children: (node) => [...node.items ?? []]
-};
-var A_CONST_VALIDATOR = {
-  node: "A_Const",
-  children: () => []
-};
-var ALIAS_VALIDATOR = {
-  node: "Alias",
-  children: (node) => [...node.colnames ?? []]
-};
-var RANGE_VAR_VALIDATOR = {
-  node: "RangeVar",
-  children: (node) => [...node.alias ? [{ Alias: node.alias }] : []],
-  validate: (node) => {
-    if (node.schemaname) {
-      throw new Error("Schema name not supported");
-    }
-    if (node.relname && SYSTEM_TABLES.has(node.relname)) {
-      throw new Error("System tables not supported");
-    }
-  }
-};
-var VAR_VALIDATOR = {
-  node: "Var",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var PARAM_VALIDATOR = {
-  node: "Param",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var AGGREF_VALIDATOR = {
-  node: "Aggref",
-  children: (node) => [
-    ...node.aggargtypes ?? [],
-    ...node.aggdirectargs ?? [],
-    ...node.args ?? [],
-    ...node.aggorder ?? [],
-    ...node.aggdistinct ?? [],
-    ...node.aggfilter ? [node.aggfilter] : []
-  ]
-};
-var GROUPING_FUNC_VALIDATOR = {
-  node: "GroupingFunc",
-  children: (node) => [...node.args ?? [], ...node.refs ?? []]
-};
-var WINDOW_FUNC_VALIDATOR = {
-  node: "WindowFunc",
-  children: (node) => [
-    ...node.args ?? [],
-    ...node.aggfilter ? [node.aggfilter] : []
-  ]
-};
-var NAMED_ARG_EXPR_VALIDATOR = {
-  node: "NamedArgExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var OP_EXPR_VALIDATOR = {
-  node: "OpExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var DISTINCT_EXPR_VALIDATOR = {
-  node: "DistinctExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var NULL_IF_EXPR_VALIDATOR = {
-  node: "NullIfExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var SCALAR_ARRAY_OP_EXPR_VALIDATOR = {
-  node: "ScalarArrayOpExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var BOOL_EXPR_VALIDATOR = {
-  node: "BoolExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var FIELD_SELECT_VALIDATOR = {
-  node: "FieldSelect",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var RELABEL_TYPE_VALIDATOR = {
-  node: "RelabelType",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var ARRAY_COERCE_EXPR_VALIDATOR = {
-  node: "ArrayCoerceExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : [],
-    ...node.elemexpr ? [node.elemexpr] : []
-  ]
-};
-var CONVERT_ROWTYPE_EXPR_VALIDATOR = {
-  node: "ConvertRowtypeExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var COLLATE_EXPR_VALIDATOR = {
-  node: "CollateExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var CASE_EXPR_VALIDATOR = {
-  node: "CaseExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : [],
-    ...node.args ?? [],
-    ...node.defresult ? [node.defresult] : []
-  ]
-};
-var CASE_WHEN_VALIDATOR = {
-  node: "CaseWhen",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.expr ? [node.expr] : [],
-    ...node.result ? [node.result] : []
-  ]
-};
-var CASE_TEST_EXPR_VALIDATOR = {
-  node: "CaseTestExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var ARRAY_EXPR_VALIDATOR = {
-  node: "ArrayExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.elements ?? []
-  ]
-};
-var ROW_EXPR_VALIDATOR = {
-  node: "RowExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.args ?? [],
-    ...node.colnames ?? []
-  ]
-};
-var ROW_COMPARE_EXPR_VALIDATOR = {
-  node: "RowCompareExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.opnos ?? [],
-    ...node.opfamilies ?? [],
-    ...node.inputcollids ?? [],
-    ...node.largs ?? [],
-    ...node.rargs ?? []
-  ]
-};
-var COALESC_EXPR_VALIDATOR = {
-  node: "CoalesceExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var MIN_MAX_EXPR_VALIDATOR = {
-  node: "MinMaxExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : [], ...node.args ?? []]
-};
-var SQL_VALUE_FUNCTION_VALIDATOR = {
-  node: "SQLValueFunction",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var JSON_FORMAT_VALIDATOR = {
-  node: "JsonFormat",
-  children: () => []
-};
-var JSON_RETURNING_VALIDATOR = {
-  node: "JsonReturning",
-  children: (node) => [...node.format ? [{ JsonFormat: node.format }] : []]
-};
-var JSON_VALUE_EXPR_VALIDATOR = {
-  node: "JsonValueExpr",
-  children: (node) => [
-    ...node.raw_expr ? [node.raw_expr] : [],
-    ...node.formatted_expr ? [node.formatted_expr] : [],
-    ...node.format ? [{ JsonFormat: node.format }] : []
-  ]
-};
-var JSON_CONSTRUCTOR_EXPR_VALIDATOR = {
-  node: "JsonConstructorExpr",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.args ?? [],
-    ...node.func ? [node.func] : [],
-    ...node.coercion ? [node.coercion] : [],
-    ...node.returning ? [{ JsonReturning: node.returning }] : []
-  ]
-};
-var JSON_IS_PREDICATE_VALIDATOR = {
-  node: "JsonIsPredicate",
-  children: (node) => [
-    ...node.expr ? [node.expr] : [],
-    ...node.format ? [{ JsonFormat: node.format }] : []
-  ]
-};
-var NULL_TEST_VALIDATOR = {
-  node: "NullTest",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var BOOLEAN_TEST_VALIDATOR = {
-  node: "BooleanTest",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var COERCE_TO_DOMAIN_VALIDATOR = {
-  node: "CoerceToDomain",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.arg ? [node.arg] : []
-  ]
-};
-var COERCE_TO_DOMAIN_VALUE_VALIDATOR = {
-  node: "CoerceToDomainValue",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var CURRENT_OF_EXPR_VALIDATOR = {
-  node: "CurrentOfExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var NEXT_VALUE_EXPR_VALIDATOR = {
-  node: "NextValueExpr",
-  children: (node) => [...node.xpr ? [node.xpr] : []]
-};
-var INFERENCE_ELEM_VALIDATOR = {
-  node: "InferenceElem",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.expr ? [node.expr] : []
-  ]
-};
-var TARGET_ENTRY_VALIDATOR = {
-  node: "TargetEntry",
-  children: (node) => [
-    ...node.xpr ? [node.xpr] : [],
-    ...node.expr ? [node.expr] : []
-  ]
-};
-var RANGE_TBL_REF_VALIDATOR = {
-  node: "RangeTblRef",
-  children: () => []
-};
-var JOIN_EXPR_VALIDATOR = {
-  node: "JoinExpr",
-  children: (node) => [
-    ...node.larg ? [node.larg] : [],
-    ...node.rarg ? [node.rarg] : [],
-    ...node.usingClause ?? [],
-    ...node.join_using_alias ? [{ Alias: node.join_using_alias }] : [],
-    ...node.quals ? [node.quals] : [],
-    ...node.alias ? [{ Alias: node.alias }] : []
-  ]
-};
-var FROM_EXPR_VALIDATOR = {
-  node: "FromExpr",
-  children: (node) => [
-    ...node.fromlist ?? [],
-    ...node.quals ? [node.quals] : []
-  ]
-};
-var ON_CONFLICT_EXPR_VALIDATOR = {
-  node: "OnConflictExpr",
-  children: (node) => [
-    ...node.arbiterElems ?? [],
-    ...node.arbiterWhere ? [node.arbiterWhere] : [],
-    ...node.onConflictSet ?? [],
-    ...node.onConflictWhere ? [node.onConflictWhere] : [],
-    ...node.exclRelTlist ?? []
-  ]
-};
-var TYPE_NAME_VALIDATOR = {
-  node: "TypeName",
-  children: (node) => [
-    ...node.names ?? [],
-    ...node.typmods ?? [],
-    ...node.arrayBounds ?? []
-  ]
-};
-var COLUMN_REF_VALIDATOR = {
-  node: "ColumnRef",
-  children: (node) => [...node.fields ?? []]
-};
-var PARAM_REF_VALIDATOR = {
-  node: "ParamRef",
-  children: () => []
-};
-var A_EXPR_VALIDATOR = {
-  node: "A_Expr",
-  children: (node) => [
-    ...node.name ?? [],
-    ...node.lexpr ? [node.lexpr] : [],
-    ...node.rexpr ? [node.rexpr] : []
-  ]
-};
-var TYPE_CAST_VALIDATOR = {
-  node: "TypeCast",
-  children: (node) => [
-    ...node.arg ? [node.arg] : [],
-    ...node.typeName ? [{ TypeName: node.typeName }] : []
-  ]
-};
-var COLLATE_CLAUSE_VALIDATOR = {
-  node: "CollateClause",
-  children: (node) => [
-    ...node.arg ? [node.arg] : [],
-    ...node.collname ?? []
-  ]
-};
-var ALLOWED_FUNCTIONS = /* @__PURE__ */ new Set([
-  "count",
-  "sum",
-  "avg",
-  "min",
-  "max",
-  "lower",
-  "upper",
-  "length",
-  "trim",
-  "replace",
-  "substring",
-  "cast",
-  "concat",
-  "now",
-  "current_timestamp",
-  "current_date",
-  "current_time",
-  "coalesce",
-  "json_agg",
-  "json_object",
-  "json_array",
-  "json_object_agg",
-  "json_array_agg"
-]);
-var FUNC_CALL_VALIDATOR = {
-  node: "FuncCall",
-  children: (node) => [
-    ...node.funcname ?? [],
-    ...node.args ?? [],
-    ...node.agg_order ?? [],
-    ...node.agg_filter ? [node.agg_filter] : [],
-    ...node.over ? [{ WindowDef: node.over }] : []
-  ],
-  validate: (node) => {
-    if (node.funcname?.every(
-      (name) => getNodeType(name) === "String" && // @ts-ignore
-      ALLOWED_FUNCTIONS.has(name.String.sval)
-    )) {
-      return;
-    }
-    throw new Error("Function call not supported");
-  }
-};
-var A_STAR_VALIDATOR = {
-  node: "A_Star",
-  children: () => []
-};
-var A_INDICES_VALIDATOR = {
-  node: "A_Indices",
-  children: (node) => [
-    ...node.lidx ? [node.lidx] : [],
-    ...node.uidx ? [node.uidx] : []
-  ]
-};
-var A_INDIRECTION_VALIDATOR = {
-  node: "A_Indirection",
-  children: (node) => [
-    ...node.arg ? [node.arg] : [],
-    ...node.indirection ?? []
-  ]
-};
-var A_ARRAY_EXPR_VALIDATOR = {
-  node: "A_ArrayExpr",
-  children: (node) => [...node.elements ?? []]
-};
-var RES_TARGET_VALIDATOR = {
-  node: "ResTarget",
-  children: (node) => [
-    ...node.indirection ?? [],
-    ...node.val ? [node.val] : []
-  ]
-};
-var MULTI_ASSIGN_REF_VALIDATOR = {
-  node: "MultiAssignRef",
-  children: (node) => [...node.source ? [node.source] : []]
-};
-var SORT_BY_VALIDATOR = {
-  node: "SortBy",
-  children: (node) => [
-    ...node.node ? [node.node] : [],
-    ...node.useOp ?? []
-  ]
-};
-var RANGE_SUBSELECT_VALIDATOR = {
-  node: "RangeSubselect",
-  children: (node) => [
-    ...node.subquery ? [node.subquery] : [],
-    ...node.alias ? [{ Alias: node.alias }] : []
-  ]
-};
-var SORT_GROUP_CLAUSE_VALIDATOR = {
-  node: "SortGroupClause",
-  children: () => []
-};
-var GROUPING_SET_VALIDATOR = {
-  node: "GroupingSet",
-  children: (node) => [...node.content ?? []]
-};
-var WITH_CLAUSE_VALIDATOR = {
-  node: "WithClause",
-  children: (node) => [...node.ctes ?? []],
-  validate: (node) => {
-    if (node.recursive) {
-      throw new Error("Recursive CTEs not supported");
-    }
-  }
-};
-var COMMON_TABLE_EXPR_VALIDATOR = {
-  node: "CommonTableExpr",
-  children: (node) => [
-    ...node.aliascolnames ?? [],
-    ...node.ctequery ? [node.ctequery] : [],
-    ...node.search_clause ? [{ CTESearchClause: node.search_clause }] : [],
-    ...node.cycle_clause ? [{ CTECycleClause: node.cycle_clause }] : [],
-    ...node.ctecolnames ?? [],
-    ...node.ctecoltypes ?? [],
-    ...node.ctecoltypmods ?? [],
-    ...node.ctecolcollations ?? []
-  ],
-  validate: (node) => {
-    if (node.ctematerialized === "CTEMaterializeAlways" || node.cterecursive) {
-      throw new Error("Invalid CTE");
-    }
-  }
-};
-var JSON_OUTPUT_VALIDATOR = {
-  node: "JsonOutput",
-  children: (node) => [
-    ...node.returning ? [{ JsonReturning: node.returning }] : []
-  ]
-};
-var JSON_KEY_VALUE_VALIDATOR = {
-  node: "JsonKeyValue",
-  children: (node) => [
-    ...node.key ? [node.key] : [],
-    ...node.value ? [{ JsonValueExpr: node.value }] : []
-  ]
-};
-var JSON_OBJECT_CONSTRUCTOR_VALIDATOR = {
-  node: "JsonObjectConstructor",
-  children: (node) => [
-    ...node.exprs ?? [],
-    ...node.output ? [{ JsonOutput: node.output }] : []
-  ]
-};
-var JSON_ARRAY_CONSTRUCTOR_VALIDATOR = {
-  node: "JsonArrayConstructor",
-  children: (node) => [
-    ...node.exprs ?? [],
-    ...node.output ? [{ JsonOutput: node.output }] : []
-  ]
-};
-var JSON_ARRAY_QUERY_CONSTRUCTOR_VALIDATOR = {
-  node: "JsonArrayQueryConstructor",
-  children: (node) => [
-    ...node.query ? [node.query] : [],
-    ...node.output ? [{ JsonOutput: node.output }] : [],
-    ...node.format ? [{ JsonFormat: node.format }] : []
-  ]
-};
-var JSON_AGG_CONSTRUCTOR_VALIDATOR = {
-  node: "JsonAggConstructor",
-  children: (node) => [
-    ...node.output ? [{ JsonOutput: node.output }] : [],
-    ...node.agg_filter ? [node.agg_filter] : [],
-    ...node.agg_order ?? [],
-    ...node.over ? [{ WindowDef: node.over }] : []
-  ]
-};
-var JSON_OBJECT_AGG_VALIDATOR = {
-  node: "JsonObjectAgg",
-  children: (node) => [
-    ...node.constructor ? [{ JsonAggConstructor: node.constructor }] : [],
-    ...node.arg ? [{ JsonKeyValue: node.arg }] : []
-  ]
-};
-var JSON_ARRAY_AGG_VALIDATOR = {
-  node: "JsonArrayAgg",
-  children: (node) => [
-    ...node.constructor ? [{ JsonAggConstructor: node.constructor }] : [],
-    ...node.arg ? [{ JsonValueExpr: node.arg }] : []
-  ]
-};
-var SELECT_STMT_VALIDATOR = {
-  node: "SelectStmt",
-  children: (node) => [
-    ...node.distinctClause ?? [],
-    ...node.intoClause ? [{ IntoClause: node.intoClause }] : [],
-    ...node.targetList ?? [],
-    ...node.fromClause ?? [],
-    ...node.whereClause ? [node.whereClause] : [],
-    ...node.groupClause ?? [],
-    ...node.havingClause ? [node.havingClause] : [],
-    ...node.windowClause ?? [],
-    ...node.valuesLists ?? [],
-    ...node.sortClause ?? [],
-    ...node.limitOffset ? [node.limitOffset] : [],
-    ...node.limitCount ? [node.limitCount] : [],
-    ...node.lockingClause ?? [],
-    ...node.withClause ? [{ WithClause: node.withClause }] : [],
-    ...node.larg ? [{ SelectStmt: node.larg }] : [],
-    ...node.rarg ? [{ SelectStmt: node.rarg }] : []
-  ],
-  validate: (node) => {
-    if (node.lockingClause) {
-      throw new Error("Invalid query");
-    }
-  }
-};
-var COMMENT_STMT_VALIDATOR = {
-  node: "CommentStmt",
-  children: (node) => [...node.object ? [node.object] : []]
-};
-var ALLOW_LIST = new Map(
-  [
-    INTEGER_VALIDATOR,
-    FLOAT_VALIDATOR,
-    BOOLEAN_VALIDATOR,
-    STRING_VALIDATOR,
-    BIT_STRING_VALIDATOR,
-    LIST_VALIDATOR,
-    OID_LIST_VALIDATOR,
-    INT_LIST_VALIDATOR,
-    A_CONST_VALIDATOR,
-    ALIAS_VALIDATOR,
-    RANGE_VAR_VALIDATOR,
-    VAR_VALIDATOR,
-    PARAM_VALIDATOR,
-    AGGREF_VALIDATOR,
-    GROUPING_FUNC_VALIDATOR,
-    WINDOW_FUNC_VALIDATOR,
-    NAMED_ARG_EXPR_VALIDATOR,
-    OP_EXPR_VALIDATOR,
-    DISTINCT_EXPR_VALIDATOR,
-    NULL_IF_EXPR_VALIDATOR,
-    SCALAR_ARRAY_OP_EXPR_VALIDATOR,
-    BOOL_EXPR_VALIDATOR,
-    FIELD_SELECT_VALIDATOR,
-    RELABEL_TYPE_VALIDATOR,
-    ARRAY_COERCE_EXPR_VALIDATOR,
-    CONVERT_ROWTYPE_EXPR_VALIDATOR,
-    COLLATE_EXPR_VALIDATOR,
-    CASE_EXPR_VALIDATOR,
-    CASE_WHEN_VALIDATOR,
-    CASE_TEST_EXPR_VALIDATOR,
-    ARRAY_EXPR_VALIDATOR,
-    ROW_EXPR_VALIDATOR,
-    ROW_COMPARE_EXPR_VALIDATOR,
-    COALESC_EXPR_VALIDATOR,
-    MIN_MAX_EXPR_VALIDATOR,
-    SQL_VALUE_FUNCTION_VALIDATOR,
-    JSON_FORMAT_VALIDATOR,
-    JSON_RETURNING_VALIDATOR,
-    JSON_VALUE_EXPR_VALIDATOR,
-    JSON_CONSTRUCTOR_EXPR_VALIDATOR,
-    JSON_IS_PREDICATE_VALIDATOR,
-    NULL_TEST_VALIDATOR,
-    BOOLEAN_TEST_VALIDATOR,
-    COERCE_TO_DOMAIN_VALIDATOR,
-    COERCE_TO_DOMAIN_VALUE_VALIDATOR,
-    CURRENT_OF_EXPR_VALIDATOR,
-    NEXT_VALUE_EXPR_VALIDATOR,
-    INFERENCE_ELEM_VALIDATOR,
-    TARGET_ENTRY_VALIDATOR,
-    RANGE_TBL_REF_VALIDATOR,
-    JOIN_EXPR_VALIDATOR,
-    FROM_EXPR_VALIDATOR,
-    ON_CONFLICT_EXPR_VALIDATOR,
-    TYPE_NAME_VALIDATOR,
-    COLUMN_REF_VALIDATOR,
-    PARAM_REF_VALIDATOR,
-    A_EXPR_VALIDATOR,
-    TYPE_CAST_VALIDATOR,
-    COLLATE_CLAUSE_VALIDATOR,
-    FUNC_CALL_VALIDATOR,
-    A_STAR_VALIDATOR,
-    A_INDICES_VALIDATOR,
-    A_INDIRECTION_VALIDATOR,
-    A_ARRAY_EXPR_VALIDATOR,
-    RES_TARGET_VALIDATOR,
-    MULTI_ASSIGN_REF_VALIDATOR,
-    SORT_BY_VALIDATOR,
-    RANGE_SUBSELECT_VALIDATOR,
-    SORT_GROUP_CLAUSE_VALIDATOR,
-    GROUPING_SET_VALIDATOR,
-    WITH_CLAUSE_VALIDATOR,
-    COMMON_TABLE_EXPR_VALIDATOR,
-    JSON_OUTPUT_VALIDATOR,
-    JSON_KEY_VALUE_VALIDATOR,
-    JSON_OBJECT_CONSTRUCTOR_VALIDATOR,
-    JSON_ARRAY_CONSTRUCTOR_VALIDATOR,
-    JSON_ARRAY_QUERY_CONSTRUCTOR_VALIDATOR,
-    JSON_AGG_CONSTRUCTOR_VALIDATOR,
-    JSON_OBJECT_AGG_VALIDATOR,
-    JSON_ARRAY_AGG_VALIDATOR,
-    SELECT_STMT_VALIDATOR,
-    COMMENT_STMT_VALIDATOR
-  ].map((node) => [node.node, node])
-);
-var SYSTEM_TABLES = /* @__PURE__ */ new Set([
-  "pg_statistic",
-  "pg_type",
-  "pg_foreign_table",
-  "pg_proc_oid_index",
-  "pg_proc_proname_args_nsp_index",
-  "pg_type_oid_index",
-  "pg_type_typname_nsp_index",
-  "pg_attribute_relid_attnam_index",
-  "pg_attribute_relid_attnum_index",
-  "pg_class_oid_index",
-  "pg_class_relname_nsp_index",
-  "pg_class_tblspc_relfilenode_index",
-  "pg_attrdef_adrelid_adnum_index",
-  "pg_attrdef_oid_index",
-  "pg_constraint_conname_nsp_index",
-  "pg_constraint_conrelid_contypid_conname_index",
-  "pg_constraint_contypid_index",
-  "pg_constraint_oid_index",
-  "pg_constraint_conparentid_index",
-  "pg_inherits_relid_seqno_index",
-  "pg_inherits_parent_index",
-  "pg_index_indrelid_index",
-  "pg_index_indexrelid_index",
-  "pg_operator_oid_index",
-  "pg_operator_oprname_l_r_n_index",
-  "pg_opfamily_am_name_nsp_index",
-  "pg_opfamily_oid_index",
-  "pg_opclass_am_name_nsp_index",
-  "pg_opclass_oid_index",
-  "pg_am_name_index",
-  "pg_am_oid_index",
-  "pg_amop_fam_strat_index",
-  "pg_amop_opr_fam_index",
-  "pg_amop_oid_index",
-  "pg_amproc_fam_proc_index",
-  "pg_amproc_oid_index",
-  "pg_language_name_index",
-  "pg_language_oid_index",
-  "pg_largeobject_metadata_oid_index",
-  "pg_largeobject_loid_pn_index",
-  "pg_aggregate_fnoid_index",
-  "pg_statistic_relid_att_inh_index",
-  "pg_statistic_ext_oid_index",
-  "pg_statistic_ext_name_index",
-  "pg_statistic_ext_relid_index",
-  "pg_statistic_ext_data_stxoid_inh_index",
-  "pg_rewrite_oid_index",
-  "pg_rewrite_rel_rulename_index",
-  "pg_trigger_tgconstraint_index",
-  "pg_trigger_tgrelid_tgname_index",
-  "pg_trigger_oid_index",
-  "pg_event_trigger_evtname_index",
-  "pg_event_trigger_oid_index",
-  "pg_description_o_c_o_index",
-  "pg_cast_oid_index",
-  "pg_cast_source_target_index",
-  "pg_enum_oid_index",
-  "pg_enum_typid_label_index",
-  "pg_enum_typid_sortorder_index",
-  "pg_namespace_nspname_index",
-  "pg_namespace_oid_index",
-  "pg_conversion_default_index",
-  "pg_conversion_name_nsp_index",
-  "pg_conversion_oid_index",
-  "pg_depend_depender_index",
-  "pg_depend_reference_index",
-  "pg_database_datname_index",
-  "pg_database_oid_index",
-  "pg_db_role_setting_databaseid_rol_index",
-  "pg_tablespace_oid_index",
-  "pg_tablespace_spcname_index",
-  "pg_authid_rolname_index",
-  "pg_authid_oid_index",
-  "pg_auth_members_oid_index",
-  "pg_auth_members_role_member_index",
-  "pg_auth_members_member_role_index",
-  "pg_auth_members_grantor_index",
-  "pg_shdepend_depender_index",
-  "pg_shdepend_reference_index",
-  "pg_shdescription_o_c_index",
-  "pg_ts_config_cfgname_index",
-  "pg_ts_config_oid_index",
-  "pg_ts_config_map_index",
-  "pg_ts_dict_dictname_index",
-  "pg_ts_dict_oid_index",
-  "pg_ts_parser_prsname_index",
-  "pg_ts_parser_oid_index",
-  "pg_ts_template_tmplname_index",
-  "pg_ts_template_oid_index",
-  "pg_extension_oid_index",
-  "pg_extension_name_index",
-  "pg_foreign_data_wrapper_oid_index",
-  "pg_foreign_data_wrapper_name_index",
-  "pg_foreign_server_oid_index",
-  "pg_foreign_server_name_index",
-  "pg_user_mapping_oid_index",
-  "pg_user_mapping_user_server_index",
-  "pg_foreign_table_relid_index",
-  "pg_policy_oid_index",
-  "pg_policy_polrelid_polname_index",
-  "pg_replication_origin_roiident_index",
-  "pg_replication_origin_roname_index",
-  "pg_default_acl_role_nsp_obj_index",
-  "pg_default_acl_oid_index",
-  "pg_init_privs_o_c_o_index",
-  "pg_seclabel_object_index",
-  "pg_shseclabel_object_index",
-  "pg_collation_name_enc_nsp_index",
-  "pg_collation_oid_index",
-  "pg_parameter_acl_parname_index",
-  "pg_parameter_acl_oid_index",
-  "pg_partitioned_table_partrelid_index",
-  "pg_range_rngtypid_index",
-  "pg_range_rngmultitypid_index",
-  "pg_transform_oid_index",
-  "pg_transform_type_lang_index",
-  "pg_sequence_seqrelid_index",
-  "pg_publication_oid_index",
-  "pg_publication_pubname_index",
-  "pg_publication_namespace_oid_index",
-  "pg_publication_namespace_pnnspid_pnpubid_index",
-  "pg_publication_rel_oid_index",
-  "pg_publication_rel_prrelid_prpubid_index",
-  "pg_publication_rel_prpubid_index",
-  "pg_subscription_oid_index",
-  "pg_subscription_subname_index",
-  "pg_subscription_rel_srrelid_srsubid_index",
-  "pg_authid",
-  "pg_shadow",
-  "pg_roles",
-  "pg_statistic_ext_data",
-  "pg_hba_file_rules",
-  "pg_settings",
-  "pg_file_settings",
-  "pg_backend_memory_contexts",
-  "pg_ident_file_mappings",
-  "pg_config",
-  "pg_shmem_allocations",
-  "pg_tables",
-  "pg_user_mapping",
-  "pg_replication_origin_status",
-  "pg_subscription",
-  "pg_attribute",
-  "pg_proc",
-  "pg_class",
-  "pg_attrdef",
-  "pg_constraint",
-  "pg_inherits",
-  "pg_index",
-  "pg_operator",
-  "pg_statio_all_sequences",
-  "pg_opfamily",
-  "pg_opclass",
-  "pg_am",
-  "pg_amop",
-  "pg_amproc",
-  "pg_language",
-  "pg_largeobject_metadata",
-  "pg_aggregate",
-  "pg_statistic_ext",
-  "pg_rewrite",
-  "pg_trigger",
-  "pg_event_trigger",
-  "pg_description",
-  "pg_cast",
-  "pg_enum",
-  "pg_namespace",
-  "pg_conversion",
-  "pg_depend",
-  "pg_database",
-  "pg_db_role_setting",
-  "pg_tablespace",
-  "pg_auth_members",
-  "pg_shdepend",
-  "pg_shdescription",
-  "pg_ts_config",
-  "pg_ts_config_map",
-  "pg_ts_dict",
-  "pg_ts_parser",
-  "pg_ts_template",
-  "pg_extension",
-  "pg_foreign_data_wrapper",
-  "pg_foreign_server",
-  "pg_policy",
-  "pg_replication_origin",
-  "pg_default_acl",
-  "pg_init_privs",
-  "pg_seclabel",
-  "pg_shseclabel",
-  "pg_collation",
-  "pg_parameter_acl",
-  "pg_partitioned_table",
-  "pg_range",
-  "pg_transform",
-  "pg_sequence",
-  "pg_publication",
-  "pg_publication_namespace",
-  "pg_publication_rel",
-  "pg_subscription_rel",
-  "pg_group",
-  "pg_user",
-  "pg_policies",
-  "pg_rules",
-  "pg_views",
-  "pg_matviews",
-  "pg_indexes",
-  "pg_sequences",
-  "pg_stats",
-  "pg_stats_ext",
-  "pg_stats_ext_exprs",
-  "pg_publication_tables",
-  "pg_locks",
-  "pg_cursors",
-  "pg_available_extensions",
-  "pg_available_extension_versions",
-  "pg_prepared_xacts",
-  "pg_prepared_statements",
-  "pg_seclabels",
-  "pg_timezone_abbrevs",
-  "pg_timezone_names",
-  "pg_stat_all_tables",
-  "pg_stat_xact_all_tables",
-  "pg_stat_xact_user_tables",
-  "pg_stat_sys_tables",
-  "pg_stat_xact_sys_tables",
-  "pg_stat_user_tables",
-  "pg_statio_all_tables",
-  "pg_statio_sys_tables",
-  "pg_statio_user_tables",
-  "pg_stat_all_indexes",
-  "pg_stat_sys_indexes",
-  "pg_stat_user_indexes",
-  "pg_statio_all_indexes",
-  "pg_statio_sys_indexes",
-  "pg_statio_user_indexes",
-  "pg_statio_sys_sequences",
-  "pg_statio_user_sequences",
-  "pg_stat_activity",
-  "pg_stat_replication",
-  "pg_stat_slru",
-  "pg_stat_wal_receiver",
-  "pg_stat_recovery_prefetch",
-  "pg_stat_subscription",
-  "pg_stat_ssl",
-  "pg_stat_gssapi",
-  "pg_replication_slots",
-  "pg_stat_replication_slots",
-  "pg_stat_database",
-  "pg_stat_database_conflicts",
-  "pg_stat_user_functions",
-  "pg_stat_xact_user_functions",
-  "pg_stat_archiver",
-  "pg_stat_bgwriter",
-  "pg_stat_io",
-  "pg_stat_wal",
-  "pg_stat_progress_analyze",
-  "pg_stat_progress_vacuum",
-  "pg_stat_progress_cluster",
-  "pg_stat_progress_create_index",
-  "pg_stat_progress_basebackup",
-  "pg_stat_progress_copy",
-  "pg_user_mappings",
-  "pg_stat_subscription_stats",
-  "pg_largeobject"
-]);
-
-// src/client/index.ts
-var status = pgTable("_ponder_status", (t) => ({
-  chainId: t.bigint({ mode: "number" }).primaryKey(),
-  blockNumber: t.bigint({ mode: "number" }),
-  blockTimestamp: t.bigint({ mode: "number" }),
-  ready: t.boolean().notNull()
-}));
-var client = ({
-  db
-}) => {
-  const session = db._.session;
-  const driver = globalThis.PONDER_DATABASE.driver;
-  let statusResolver = promiseWithResolvers();
-  const channel = `${globalThis.PONDER_NAMESPACE_BUILD}_status_channel`;
-  if ("instance" in driver) {
-    driver.instance.query(`LISTEN "${channel}"`).then(() => {
-      driver.instance.onNotification(async () => {
-        statusResolver.resolve();
-        statusResolver = promiseWithResolvers();
-      });
-    });
-  } else {
-    const pool = driver.internal;
-    const connectAndListen = async () => {
-      driver.listen = await pool.connect();
-      await driver.listen.query(`LISTEN "${channel}"`);
-      driver.listen.on("error", async () => {
-        driver.listen?.release();
-        await connectAndListen();
-      });
-      driver.listen.on("notification", () => {
-        statusResolver.resolve();
-        statusResolver = promiseWithResolvers();
-      });
-    };
-    connectAndListen();
-  }
-  return createMiddleware(async (c, next) => {
-    if (c.req.path === "/sql/db") {
-      const queryString = c.req.query("sql");
-      if (queryString === void 0) {
-        return c.text('Missing "sql" query parameter', 400);
-      }
-      const query = superjson.parse(queryString);
-      if ("instance" in driver) {
-        try {
-          await validateQuery(query.sql);
-          const result = await session.prepareQuery(query, void 0, void 0, false).execute();
-          return c.json(result);
-        } catch (error) {
-          error.stack = void 0;
-          return c.text(error.message, 500);
-        }
-      } else {
-        const client2 = await driver.internal.connect();
-        try {
-          await validateQuery(query.sql);
-          await client2.query("BEGIN READ ONLY");
-          const result = await session.prepareQuery(query, void 0, void 0, false).execute();
-          return c.json(result);
-        } catch (error) {
-          error.stack = void 0;
-          return c.text(error.message, 500);
-        } finally {
-          await client2.query("ROLLBACK");
-          client2.release();
-        }
-      }
-    }
-    if (c.req.path === "/sql/live") {
-      c.header("Content-Type", "text/event-stream");
-      c.header("Cache-Control", "no-cache");
-      c.header("Connection", "keep-alive");
-      return streamSSE(c, async (stream) => {
-        while (stream.closed === false && stream.aborted === false) {
-          try {
-            await stream.writeSSE({ data: "" });
-          } catch {
-          }
-          await statusResolver.promise;
-        }
-      });
-    }
-    if (c.req.path === "/sql/status") {
-      const statusResult = await db.select().from(status);
-      return c.json(statusResult);
-    }
-    return next();
-  });
-};
-
-// src/ui/graphiql.html.ts
-var graphiQLHtml = (path) => `<!--
- *  Copyright (c) 2021 GraphQL Contributors
- *  All rights reserved.
- *
- *  This source code is licensed under the license found in the
- *  LICENSE file in the root directory of this source tree.
--->
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <title>Ponder Playground</title>
-    <style>
-      body {
-        height: 100%;
-        margin: 0;
-        width: 100%;
-        overflow: hidden;
-      }
-      #graphiql {
-        height: 100vh;
-      }
-      *::-webkit-scrollbar {
-        height: 0.3rem;
-        width: 0.5rem;
-      }
-      *::-webkit-scrollbar-track {
-        -ms-overflow-style: none;
-        overflow: -moz-scrollbars-none;
-      }
-      *::-webkit-scrollbar-thumb {
-        -ms-overflow-style: none;
-        overflow: -moz-scrollbars-none;
-      }
-    </style>
-    <link rel="stylesheet" href="https://unpkg.com/graphiql@3.7.2/graphiql.min.css" />
-    <link rel="stylesheet" href="https://unpkg.com/@graphiql/plugin-explorer@3.2.3/dist/style.css" />
-  </head>
-  <body>
-    <div id="graphiql">Loading...</div>
-    <script crossorigin src="https://unpkg.com/react@18.3.1/umd/react.development.js"></script>1
-    <script crossorigin src="https://unpkg.com/react-dom@18.3.1/umd/react-dom.development.js"></script>
-    <script src="https://unpkg.com/graphiql@3.7.2/graphiql.min.js" crossorigin="anonymous"></script>
-    <script src="https://unpkg.com/@graphiql/plugin-explorer@3.2.3/dist/index.umd.js" crossorigin="anonymous"></script>
-    <script>
-      const fetcher = GraphiQL.createFetcher({ url: "${path}" });
-      const explorerPlugin = GraphiQLPluginExplorer.explorerPlugin();
-      const root = ReactDOM.createRoot(document.getElementById("graphiql"));
-      root.render(
-        React.createElement(GraphiQL, {
-          fetcher,
-          plugins: [explorerPlugin],
-          defaultEditorToolsVisibility: false,
-        })
-      );
-    </script>
-  </body>
-</html>`;
-
-// src/graphql/middleware.ts
-import { maxAliasesPlugin } from "@escape.tech/graphql-armor-max-aliases";
-import { maxDepthPlugin } from "@escape.tech/graphql-armor-max-depth";
-import { maxTokensPlugin } from "@escape.tech/graphql-armor-max-tokens";
-import { printSchema } from "graphql";
-import { createYoga } from "graphql-yoga";
-import { createMiddleware as createMiddleware2 } from "hono/factory";
-
-// src/graphql/index.ts
-import DataLoader from "dataloader";
-import {
-  Many,
-  One,
-  and,
-  arrayContained,
-  arrayContains,
-  asc,
-  count,
-  createTableRelationsHelpers,
-  desc,
-  eq,
-  extractTablesRelationalConfig,
-  getTableColumns,
-  gt,
-  gte,
-  inArray,
-  is,
-  like,
-  lt,
-  lte,
-  ne,
-  not,
-  notInArray,
-  notLike,
-  or
-} from "drizzle-orm";
-import {
-  PgEnumColumn,
-  PgInteger,
-  PgSerial,
-  isPgEnum
-} from "drizzle-orm/pg-core";
-import {
-  GraphQLBoolean,
-  GraphQLEnumType,
-  GraphQLFloat,
-  GraphQLInputObjectType,
-  GraphQLInt,
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLObjectType,
-  GraphQLScalarType as GraphQLScalarType2,
-  GraphQLSchema,
-  GraphQLString
-} from "graphql";
-
-// src/graphql/json.ts
-import {
-  GraphQLScalarType,
-  Kind,
-  print
-} from "graphql";
-var GraphQLJSON = new GraphQLScalarType({
-  name: "JSON",
-  description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
-  serialize: (x) => x,
-  parseValue: (x) => x,
-  parseLiteral: (ast, variables) => {
-    if (ast.kind !== Kind.OBJECT) {
-      throw new TypeError(
-        `JSONObject cannot represent non-object value: ${print(ast)}`
-      );
-    }
-    return parseObject(ast, variables);
-  }
-});
-var parseLiteral = (ast, variables) => {
-  switch (ast.kind) {
-    case Kind.STRING:
-    case Kind.BOOLEAN:
-      return ast.value;
-    case Kind.INT:
-    case Kind.FLOAT:
-      return Number.parseFloat(ast.value);
-    case Kind.OBJECT:
-      return parseObject(ast, variables);
-    case Kind.LIST:
-      return ast.values.map((n) => parseLiteral(n, variables));
-    case Kind.NULL:
-      return null;
-    case Kind.VARIABLE:
-      return variables ? variables[ast.name.value] : void 0;
-    default:
-      throw new TypeError(`JSON cannot represent value: ${print(ast)}`);
-  }
-};
-var parseObject = (ast, variables) => {
-  const value = /* @__PURE__ */ Object.create(null);
-  ast.fields.forEach((field) => {
-    value[field.name.value] = parseLiteral(field.value, variables);
-  });
-  return value;
-};
-
-// src/graphql/index.ts
-var DEFAULT_LIMIT = 50;
-var MAX_LIMIT = 1e3;
-function buildGraphQLSchema({
-  schema
-}) {
-  const tablesConfig = extractTablesRelationalConfig(
-    schema,
-    createTableRelationsHelpers
-  );
-  const tables = Object.values(tablesConfig.tables);
-  const enums = Object.entries(schema).filter(
-    (el) => isPgEnum(el[1])
-  );
-  const enumTypes = {};
-  for (const [enumTsName, enumObject] of enums) {
-    enumTypes[enumObject.enumName] = new GraphQLEnumType({
-      name: enumTsName,
-      values: enumObject.enumValues.reduce(
-        (acc, cur) => ({ ...acc, [cur]: {} }),
-        {}
-      )
-    });
-  }
-  const entityFilterTypes = {};
-  for (const table of tables) {
-    const filterType = new GraphQLInputObjectType({
-      name: `${table.tsName}Filter`,
-      fields: () => {
-        const filterFields = {
-          // Logical operators
-          AND: { type: new GraphQLList(filterType) },
-          OR: { type: new GraphQLList(filterType) }
-        };
-        for (const [columnName, column] of Object.entries(table.columns)) {
-          const type = columnToGraphQLCore(column, enumTypes);
-          if (type instanceof GraphQLList) {
-            const baseType = innerType(type);
-            conditionSuffixes.universal.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type: new GraphQLList(baseType)
-              };
-            });
-            conditionSuffixes.plural.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = { type: baseType };
-            });
-          }
-          if (type instanceof GraphQLScalarType2 || type instanceof GraphQLEnumType) {
-            if (type.name === "JSON")
-              continue;
-            conditionSuffixes.universal.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type
-              };
-            });
-            conditionSuffixes.singular.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type: new GraphQLList(type)
-              };
-            });
-            if (["String", "ID"].includes(type.name)) {
-              conditionSuffixes.string.forEach((suffix) => {
-                filterFields[`${columnName}${suffix}`] = {
-                  type
-                };
-              });
-            }
-            if (["Int", "Float", "BigInt"].includes(type.name)) {
-              conditionSuffixes.numeric.forEach((suffix) => {
-                filterFields[`${columnName}${suffix}`] = {
-                  type
-                };
-              });
-            }
-          }
-        }
-        return filterFields;
-      }
-    });
-    entityFilterTypes[table.tsName] = filterType;
-  }
-  const entityTypes = {};
-  const entityPageTypes = {};
-  for (const table of tables) {
-    entityTypes[table.tsName] = new GraphQLObjectType({
-      name: table.tsName,
-      fields: () => {
-        const fieldConfigMap = {};
-        for (const [columnName, column] of Object.entries(table.columns)) {
-          const type = columnToGraphQLCore(column, enumTypes);
-          fieldConfigMap[columnName] = {
-            type: column.notNull ? new GraphQLNonNull(type) : type
-          };
-        }
-        const relations2 = Object.entries(table.relations);
-        for (const [relationName, relation] of relations2) {
-          const referencedTable = tables.find(
-            (table2) => table2.dbName === relation.referencedTableName
-          );
-          if (!referencedTable)
-            throw new Error(
-              `Internal error: Referenced table "${relation.referencedTableName}" not found`
-            );
-          const referencedEntityType = entityTypes[referencedTable.tsName];
-          const referencedEntityPageType = entityPageTypes[referencedTable.tsName];
-          const referencedEntityFilterType = entityFilterTypes[referencedTable.tsName];
-          if (referencedEntityType === void 0 || referencedEntityPageType === void 0 || referencedEntityFilterType === void 0)
-            throw new Error(
-              `Internal error: Referenced entity types not found for table "${referencedTable.tsName}" `
-            );
-          if (is(relation, One)) {
-            const fields = relation.config?.fields ?? [];
-            const references = relation.config?.references ?? [];
-            if (fields.length !== references.length) {
-              throw new Error(
-                "Internal error: Fields and references arrays must be the same length"
-              );
-            }
-            fieldConfigMap[relationName] = {
-              // Note: There is a `relation.isNullable` field here but it appears
-              // to be internal / incorrect. Until we have support for foriegn
-              // key constraints, all `one` relations must be nullable.
-              type: referencedEntityType,
-              resolve: (parent, _args, context) => {
-                const loader = context.getDataLoader({
-                  table: referencedTable
-                });
-                const rowFragment = {};
-                for (let i = 0; i < references.length; i++) {
-                  const referenceColumn = references[i];
-                  const fieldColumn = fields[i];
-                  const fieldColumnTsName = getColumnTsName(fieldColumn);
-                  const referenceColumnTsName = getColumnTsName(referenceColumn);
-                  rowFragment[referenceColumnTsName] = parent[fieldColumnTsName];
-                }
-                const encodedId = encodeRowFragment(rowFragment);
-                return loader.load(encodedId);
-              }
-            };
-          } else if (is(relation, Many)) {
-            const oneRelation = Object.values(referencedTable.relations).find(
-              (relation2) => relation2.relationName === relationName || is(relation2, One) && relation2.referencedTableName === table.dbName
-            );
-            if (!oneRelation)
-              throw new Error(
-                `Internal error: Relation "${relationName}" not found in table "${referencedTable.tsName}"`
-              );
-            const fields = oneRelation.config?.fields ?? [];
-            const references = oneRelation.config?.references ?? [];
-            fieldConfigMap[relationName] = {
-              type: referencedEntityPageType,
-              args: {
-                where: { type: referencedEntityFilterType },
-                orderBy: { type: GraphQLString },
-                orderDirection: { type: GraphQLString },
-                before: { type: GraphQLString },
-                after: { type: GraphQLString },
-                limit: { type: GraphQLInt }
-              },
-              resolve: (parent, args, context, info) => {
-                const relationalConditions = [];
-                for (let i = 0; i < references.length; i++) {
-                  const column = fields[i];
-                  const value = parent[references[i].name];
-                  relationalConditions.push(eq(column, value));
-                }
-                const includeTotalCount = selectionIncludesField(
-                  info,
-                  "totalCount"
-                );
-                return executePluralQuery(
-                  referencedTable,
-                  context.drizzle,
-                  args,
-                  includeTotalCount,
-                  relationalConditions
-                );
-              }
-            };
-          } else {
-            throw new Error(
-              `Internal error: Relation "${relationName}" is unsupported, expected One or Many`
-            );
-          }
-        }
-        return fieldConfigMap;
-      }
-    });
-    entityPageTypes[table.tsName] = new GraphQLObjectType({
-      name: `${table.tsName}Page`,
-      fields: () => ({
-        items: {
-          type: new GraphQLNonNull(
-            new GraphQLList(new GraphQLNonNull(entityTypes[table.tsName]))
-          )
-        },
-        pageInfo: { type: new GraphQLNonNull(GraphQLPageInfo) },
-        totalCount: { type: new GraphQLNonNull(GraphQLInt) }
-      })
-    });
-  }
-  const queryFields = {};
-  for (const table of tables) {
-    const entityType = entityTypes[table.tsName];
-    const entityPageType = entityPageTypes[table.tsName];
-    const entityFilterType = entityFilterTypes[table.tsName];
-    const singularFieldName = table.tsName.charAt(0).toLowerCase() + table.tsName.slice(1);
-    const pluralFieldName = `${singularFieldName}s`;
-    queryFields[singularFieldName] = {
-      type: entityType,
-      // Find the primary key columns and GraphQL core types and include them
-      // as arguments to the singular query type.
-      args: Object.fromEntries(
-        table.primaryKey.map((column) => [
-          getColumnTsName(column),
-          {
-            type: new GraphQLNonNull(
-              columnToGraphQLCore(column, enumTypes)
-            )
-          }
-        ])
-      ),
-      resolve: async (_parent, args, context) => {
-        const loader = context.getDataLoader({ table });
-        const encodedId = encodeRowFragment(args);
-        return loader.load(encodedId);
-      }
-    };
-    queryFields[pluralFieldName] = {
-      type: new GraphQLNonNull(entityPageType),
-      args: {
-        where: { type: entityFilterType },
-        orderBy: { type: GraphQLString },
-        orderDirection: { type: GraphQLString },
-        before: { type: GraphQLString },
-        after: { type: GraphQLString },
-        limit: { type: GraphQLInt }
-      },
-      resolve: async (_parent, args, context, info) => {
-        const includeTotalCount = selectionIncludesField(info, "totalCount");
-        return executePluralQuery(
-          table,
-          context.drizzle,
-          args,
-          includeTotalCount
-        );
-      }
-    };
-  }
-  queryFields._meta = {
-    type: GraphQLMeta,
-    resolve: async (_source, _args, context) => {
-      const status2 = await context.metadataStore.getStatus();
-      return { status: status2 };
-    }
-  };
-  return new GraphQLSchema({
-    // Include these here so they are listed first in the printed schema.
-    types: [GraphQLJSON, GraphQLBigInt, GraphQLPageInfo, GraphQLMeta],
-    query: new GraphQLObjectType({
-      name: "Query",
-      fields: queryFields
-    })
-  });
-}
-var GraphQLPageInfo = new GraphQLObjectType({
-  name: "PageInfo",
-  fields: {
-    hasNextPage: { type: new GraphQLNonNull(GraphQLBoolean) },
-    hasPreviousPage: { type: new GraphQLNonNull(GraphQLBoolean) },
-    startCursor: { type: GraphQLString },
-    endCursor: { type: GraphQLString }
-  }
-});
-var GraphQLBigInt = new GraphQLScalarType2({
-  name: "BigInt",
-  serialize: (value) => String(value),
-  parseValue: (value) => BigInt(value),
-  parseLiteral: (value) => {
-    if (value.kind === "StringValue") {
-      return BigInt(value.value);
-    } else {
-      throw new Error(
-        `Invalid value kind provided for field of type BigInt: ${value.kind}. Expected: StringValue`
-      );
-    }
-  }
-});
-var GraphQLMeta = new GraphQLObjectType({
-  name: "Meta",
-  fields: { status: { type: GraphQLJSON } }
-});
-var columnToGraphQLCore = (column, enumTypes) => {
-  if (column.columnType === "PgEvmBigint") {
-    return GraphQLBigInt;
-  }
-  if (column instanceof PgEnumColumn) {
-    if (column.enum === void 0) {
-      throw new Error(
-        `Internal error: Expected enum column "${getColumnTsName(column)}" to have an "enum" property`
-      );
-    }
-    const enumType = enumTypes[column.enum.enumName];
-    if (enumType === void 0) {
-      throw new Error(
-        `Internal error: Expected to find a GraphQL enum named "${column.enum.enumName}"`
-      );
-    }
-    return enumType;
-  }
-  switch (column.dataType) {
-    case "boolean":
-      return GraphQLBoolean;
-    case "json":
-      return GraphQLJSON;
-    case "date":
-      return GraphQLString;
-    case "string":
-      return GraphQLString;
-    case "bigint":
-      return GraphQLString;
-    case "number":
-      return is(column, PgInteger) || is(column, PgSerial) ? GraphQLInt : GraphQLFloat;
-    case "buffer":
-      return new GraphQLList(new GraphQLNonNull(GraphQLInt));
-    case "array": {
-      if (column.columnType === "PgVector") {
-        return new GraphQLList(new GraphQLNonNull(GraphQLFloat));
-      }
-      if (column.columnType === "PgGeometry") {
-        return new GraphQLList(new GraphQLNonNull(GraphQLFloat));
-      }
-      const innerType2 = columnToGraphQLCore(
-        column.baseColumn,
-        enumTypes
-      );
-      return new GraphQLList(new GraphQLNonNull(innerType2));
-    }
-    default:
-      throw new Error(`Type ${column.dataType} is not implemented`);
-  }
-};
-var innerType = (type) => {
-  if (type instanceof GraphQLScalarType2 || type instanceof GraphQLEnumType)
-    return type;
-  if (type instanceof GraphQLList || type instanceof GraphQLNonNull)
-    return innerType(type.ofType);
-  throw new Error(`Type ${type.toString()} is not implemented`);
-};
-async function executePluralQuery(table, drizzle, args, includeTotalCount, extraConditions = []) {
-  const rawTable = drizzle._.fullSchema[table.tsName];
-  const baseQuery = drizzle.query[table.tsName];
-  if (rawTable === void 0 || baseQuery === void 0)
-    throw new Error(`Internal error: Table "${table.tsName}" not found in RQB`);
-  const limit = args.limit ?? DEFAULT_LIMIT;
-  if (limit > MAX_LIMIT) {
-    throw new Error(`Invalid limit. Got ${limit}, expected <=${MAX_LIMIT}.`);
-  }
-  const orderBySchema = buildOrderBySchema(table, args);
-  const orderBy = orderBySchema.map(([columnName, direction]) => {
-    const column = table.columns[columnName];
-    if (column === void 0) {
-      throw new Error(
-        `Unknown column "${columnName}" used in orderBy argument`
-      );
-    }
-    return direction === "asc" ? asc(column) : desc(column);
-  });
-  const orderByReversed = orderBySchema.map(([columnName, direction]) => {
-    const column = table.columns[columnName];
-    if (column === void 0) {
-      throw new Error(
-        `Unknown column "${columnName}" used in orderBy argument`
-      );
-    }
-    return direction === "asc" ? desc(column) : asc(column);
-  });
-  const whereConditions = buildWhereConditions(args.where, table.columns);
-  const after = args.after ?? null;
-  const before = args.before ?? null;
-  if (after !== null && before !== null) {
-    throw new Error("Cannot specify both before and after cursors.");
-  }
-  let startCursor = null;
-  let endCursor = null;
-  let hasPreviousPage = false;
-  let hasNextPage = false;
-  const totalCountPromise = includeTotalCount ? drizzle.select({ count: count() }).from(rawTable).where(and(...whereConditions, ...extraConditions)).then((rows2) => rows2[0]?.count ?? null) : Promise.resolve(null);
-  if (after === null && before === null) {
-    const [rows2, totalCount2] = await Promise.all([
-      baseQuery.findMany({
-        where: and(...whereConditions, ...extraConditions),
-        orderBy,
-        limit: limit + 1
-      }),
-      totalCountPromise
-    ]);
-    if (rows2.length === limit + 1) {
-      rows2.pop();
-      hasNextPage = true;
-    }
-    startCursor = rows2.length > 0 ? encodeCursor(orderBySchema, rows2[0]) : null;
-    endCursor = rows2.length > 0 ? encodeCursor(orderBySchema, rows2[rows2.length - 1]) : null;
-    return {
-      items: rows2,
-      totalCount: totalCount2,
-      pageInfo: { hasNextPage, hasPreviousPage, startCursor, endCursor }
-    };
-  }
-  if (after !== null) {
-    const cursorObject2 = decodeCursor(after);
-    const cursorCondition2 = buildCursorCondition(
-      table,
-      orderBySchema,
-      "after",
-      cursorObject2
-    );
-    const [rows2, totalCount2] = await Promise.all([
-      baseQuery.findMany({
-        where: and(...whereConditions, cursorCondition2, ...extraConditions),
-        orderBy,
-        limit: limit + 2
-      }),
-      totalCountPromise
-    ]);
-    if (rows2.length === 0) {
-      return {
-        items: rows2,
-        totalCount: totalCount2,
-        pageInfo: { hasNextPage, hasPreviousPage, startCursor, endCursor }
-      };
-    }
-    if (encodeCursor(orderBySchema, rows2[0]) === after) {
-      rows2.shift();
-      hasPreviousPage = true;
-    } else {
-      rows2.pop();
-    }
-    if (rows2.length === limit + 1) {
-      rows2.pop();
-      hasNextPage = true;
-    }
-    startCursor = rows2.length > 0 ? encodeCursor(orderBySchema, rows2[0]) : null;
-    endCursor = rows2.length > 0 ? encodeCursor(orderBySchema, rows2[rows2.length - 1]) : null;
-    return {
-      items: rows2,
-      totalCount: totalCount2,
-      pageInfo: { hasNextPage, hasPreviousPage, startCursor, endCursor }
-    };
-  }
-  const cursorObject = decodeCursor(before);
-  const cursorCondition = buildCursorCondition(
-    table,
-    orderBySchema,
-    "before",
-    cursorObject
-  );
-  const [rows, totalCount] = await Promise.all([
-    baseQuery.findMany({
-      where: and(...whereConditions, cursorCondition, ...extraConditions),
-      orderBy: orderByReversed,
-      limit: limit + 2
-    }).then((rows2) => rows2.reverse()),
-    totalCountPromise
-  ]);
-  if (rows.length === 0) {
-    return {
-      items: rows,
-      totalCount,
-      pageInfo: { hasNextPage, hasPreviousPage, startCursor, endCursor }
-    };
-  }
-  if (encodeCursor(orderBySchema, rows[rows.length - 1]) === before) {
-    rows.pop();
-    hasNextPage = true;
-  } else {
-    rows.shift();
-  }
-  if (rows.length === limit + 1) {
-    rows.shift();
-    hasPreviousPage = true;
-  }
-  startCursor = rows.length > 0 ? encodeCursor(orderBySchema, rows[0]) : null;
-  endCursor = rows.length > 0 ? encodeCursor(orderBySchema, rows[rows.length - 1]) : null;
-  return {
-    items: rows,
-    totalCount,
-    pageInfo: { hasNextPage, hasPreviousPage, startCursor, endCursor }
-  };
-}
-var conditionSuffixes = {
-  universal: ["", "_not"],
-  singular: ["_in", "_not_in"],
-  plural: ["_has", "_not_has"],
-  numeric: ["_gt", "_lt", "_gte", "_lte"],
-  string: [
-    "_contains",
-    "_not_contains",
-    "_starts_with",
-    "_ends_with",
-    "_not_starts_with",
-    "_not_ends_with"
-  ]
-};
-var conditionSuffixesByLengthDesc = Object.values(conditionSuffixes).flat().sort((a, b) => b.length - a.length);
-function buildWhereConditions(where, columns) {
-  const conditions = [];
-  if (where === void 0)
-    return conditions;
-  for (const [whereKey, rawValue] of Object.entries(where)) {
-    if (whereKey === "AND" || whereKey === "OR") {
-      if (!Array.isArray(rawValue)) {
-        throw new Error(
-          `Invalid query: Expected an array for the ${whereKey} operator. Got: ${rawValue}`
-        );
-      }
-      const nestedConditions = rawValue.flatMap(
-        (subWhere) => buildWhereConditions(subWhere, columns)
-      );
-      if (nestedConditions.length > 0) {
-        conditions.push(
-          whereKey === "AND" ? and(...nestedConditions) : or(...nestedConditions)
-        );
-      }
-      continue;
-    }
-    const conditionSuffix = conditionSuffixesByLengthDesc.find(
-      (s) => whereKey.endsWith(s)
-    );
-    if (conditionSuffix === void 0) {
-      throw new Error(
-        `Invariant violation: Condition suffix not found for where key ${whereKey}`
-      );
-    }
-    const columnName = whereKey.slice(
-      0,
-      whereKey.length - conditionSuffix.length
-    );
-    const column = columns[columnName];
-    if (column === void 0) {
-      throw new Error(
-        `Invalid query: Where clause contains unknown column ${columnName}`
-      );
-    }
-    switch (conditionSuffix) {
-      case "":
-        if (column.columnType === "PgArray") {
-          conditions.push(
-            and(
-              arrayContains(column, rawValue),
-              arrayContained(column, rawValue)
-            )
-          );
-        } else {
-          conditions.push(eq(column, rawValue));
-        }
-        break;
-      case "_not":
-        if (column.columnType === "PgArray") {
-          conditions.push(
-            not(
-              and(
-                arrayContains(column, rawValue),
-                arrayContained(column, rawValue)
-              )
-            )
-          );
-        } else {
-          conditions.push(ne(column, rawValue));
-        }
-        break;
-      case "_in":
-        conditions.push(inArray(column, rawValue));
-        break;
-      case "_not_in":
-        conditions.push(notInArray(column, rawValue));
-        break;
-      case "_has":
-        conditions.push(arrayContains(column, [rawValue]));
-        break;
-      case "_not_has":
-        conditions.push(not(arrayContains(column, [rawValue])));
-        break;
-      case "_gt":
-        conditions.push(gt(column, rawValue));
-        break;
-      case "_lt":
-        conditions.push(lt(column, rawValue));
-        break;
-      case "_gte":
-        conditions.push(gte(column, rawValue));
-        break;
-      case "_lte":
-        conditions.push(lte(column, rawValue));
-        break;
-      case "_contains":
-        conditions.push(like(column, `%${rawValue}%`));
-        break;
-      case "_not_contains":
-        conditions.push(notLike(column, `%${rawValue}%`));
-        break;
-      case "_starts_with":
-        conditions.push(like(column, `${rawValue}%`));
-        break;
-      case "_ends_with":
-        conditions.push(like(column, `%${rawValue}`));
-        break;
-      case "_not_starts_with":
-        conditions.push(notLike(column, `${rawValue}%`));
-        break;
-      case "_not_ends_with":
-        conditions.push(notLike(column, `%${rawValue}`));
-        break;
-      default:
-        never(conditionSuffix);
-    }
-  }
-  return conditions;
-}
-function buildOrderBySchema(table, args) {
-  const userDirection = args.orderDirection ?? "asc";
-  const userColumns = args.orderBy !== void 0 ? [[args.orderBy, userDirection]] : [];
-  const pkColumns = table.primaryKey.map((column) => [
-    getColumnTsName(column),
-    userDirection
-  ]);
-  const missingPkColumns = pkColumns.filter(
-    (pkColumn) => !userColumns.some((userColumn) => userColumn[0] === pkColumn[0])
-  );
-  return [...userColumns, ...missingPkColumns];
-}
-function encodeCursor(orderBySchema, row) {
-  const cursorObject = Object.fromEntries(
-    orderBySchema.map(([columnName, _]) => [columnName, row[columnName]])
-  );
-  return encodeRowFragment(cursorObject);
-}
-function decodeCursor(cursor) {
-  return decodeRowFragment(cursor);
-}
-function encodeRowFragment(rowFragment) {
-  return Buffer.from(serialize(rowFragment)).toString("base64");
-}
-function decodeRowFragment(encodedRowFragment) {
-  return deserialize(Buffer.from(encodedRowFragment, "base64").toString());
-}
-function buildCursorCondition(table, orderBySchema, direction, cursorObject) {
-  const cursorColumns = orderBySchema.map(([columnName, orderDirection]) => {
-    const column = table.columns[columnName];
-    if (column === void 0)
-      throw new Error(
-        `Unknown column "${columnName}" used in orderBy argument`
-      );
-    const value = cursorObject[columnName];
-    let comparator;
-    let comparatorOrEquals;
-    if (direction === "after") {
-      [comparator, comparatorOrEquals] = orderDirection === "asc" ? [gt, gte] : [lt, lte];
-    } else {
-      [comparator, comparatorOrEquals] = orderDirection === "asc" ? [lt, lte] : [gt, gte];
-    }
-    return { column, value, comparator, comparatorOrEquals };
-  });
-  const buildCondition = (index2) => {
-    if (index2 === cursorColumns.length - 1) {
-      const { column, value, comparatorOrEquals } = cursorColumns[index2];
-      return comparatorOrEquals(column, value);
-    }
-    const currentColumn = cursorColumns[index2];
-    const nextCondition = buildCondition(index2 + 1);
-    return or(
-      currentColumn.comparator(currentColumn.column, currentColumn.value),
-      and(eq(currentColumn.column, currentColumn.value), nextCondition)
-    );
-  };
-  return buildCondition(0);
-}
-function buildDataLoaderCache({
-  drizzle
-}) {
-  const dataLoaderMap = /* @__PURE__ */ new Map();
-  return ({ table }) => {
-    const baseQuery = drizzle.query[table.tsName];
-    if (baseQuery === void 0)
-      throw new Error(
-        `Internal error: Unknown table "${table.tsName}" in data loader cache`
-      );
-    let dataLoader = dataLoaderMap.get(table);
-    if (dataLoader === void 0) {
-      dataLoader = new DataLoader(
-        async (encodedIds) => {
-          const decodedRowFragments = encodedIds.map(decodeRowFragment);
-          const idConditions = decodedRowFragments.map(
-            (decodedRowFragment) => and(...buildWhereConditions(decodedRowFragment, table.columns))
-          );
-          const rows = await baseQuery.findMany({
-            where: or(...idConditions),
-            limit: encodedIds.length
-          });
-          return decodedRowFragments.map((decodedRowFragment) => {
-            return rows.find(
-              (row) => Object.entries(decodedRowFragment).every(
-                ([col, val]) => row[col] === val
-              )
-            );
-          });
-        },
-        { maxBatchSize: 1e3 }
-      );
-      dataLoaderMap.set(table, dataLoader);
-    }
-    return dataLoader;
-  };
-}
-function getColumnTsName(column) {
-  const tableColumns = getTableColumns(column.table);
-  return Object.entries(tableColumns).find(
-    ([_, c]) => c.name === column.name
-  )[0];
-}
-function selectionIncludesField(info, fieldName) {
-  for (const fieldNode of info.fieldNodes) {
-    for (const selection of fieldNode.selectionSet?.selections ?? []) {
-      if (selection.kind === "Field" && selection.name.value === fieldName) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-// src/graphql/middleware.ts
-var graphql = ({ db, schema }, {
-  maxOperationTokens = 1e3,
-  maxOperationDepth = 100,
-  maxOperationAliases = 30
-} = {
-  // Default limits are from Apollo:
-  // https://www.apollographql.com/blog/prevent-graph-misuse-with-operation-size-and-complexity-limit
-  maxOperationTokens: 1e3,
-  maxOperationDepth: 100,
-  maxOperationAliases: 30
-}) => {
-  const graphqlSchema = buildGraphQLSchema({ schema });
-  generateSchema({ graphqlSchema }).catch(() => {
-  });
-  const metadataStore = getMetadataStore({
-    database: globalThis.PONDER_DATABASE
-  });
-  const yoga = createYoga({
-    graphqlEndpoint: "*",
-    // Disable built-in route validation, use Hono routing instead
-    schema: graphqlSchema,
-    context: () => {
-      const getDataLoader = buildDataLoaderCache({ drizzle: db });
-      return { drizzle: db, metadataStore, getDataLoader };
-    },
-    maskedErrors: process.env.NODE_ENV === "production",
-    logging: false,
-    graphiql: false,
-    parserAndValidationCache: false,
-    plugins: [
-      maxTokensPlugin({ n: maxOperationTokens }),
-      maxDepthPlugin({ n: maxOperationDepth, ignoreIntrospection: false }),
-      maxAliasesPlugin({ n: maxOperationAliases, allowList: [] })
-    ]
-  });
-  return createMiddleware2(async (c) => {
-    if (c.req.method === "GET") {
-      return c.html(graphiQLHtml(c.req.path));
-    }
-    const response = await yoga.handle(c.req.raw);
-    response.status = 200;
-    response.statusText = "OK";
-    return response;
-  });
-};
-async function generateSchema({
-  graphqlSchema
-}) {
-  const fs = await import(
-    /* webpackIgnore: true */
-    "node:fs"
-  );
-  const path = await import(
-    /* webpackIgnore: true */
-    "node:path"
-  );
-  fs.mkdirSync(path.join(process.cwd(), "generated"), { recursive: true });
-  fs.writeFileSync(
-    path.join(process.cwd(), "generated", "schema.graphql"),
-    printSchema(graphqlSchema),
-    "utf-8"
-  );
-}
-
-// src/index.ts
-import {
-  sql,
-  eq as eq2,
-  gt as gt2,
-  gte as gte2,
-  lt as lt2,
-  lte as lte2,
-  ne as ne2,
-  isNull,
-  isNotNull,
-  inArray as inArray2,
-  notInArray as notInArray2,
-  exists,
-  notExists,
-  between,
-  notBetween,
-  like as like2,
-  notLike as notLike2,
-  ilike,
-  notIlike,
-  not as not2,
-  asc as asc2,
-  desc as desc2,
-  and as and2,
-  or as or2,
-  count as count2,
-  countDistinct,
-  avg,
-  avgDistinct,
-  sum,
-  sumDistinct,
-  max,
-  min,
-  relations
-} from "drizzle-orm";
-import {
-  bigint as bigint2,
-  boolean,
-  char,
-  cidr,
-  date,
-  doublePrecision,
-  inet,
-  integer,
-  interval,
-  json,
-  jsonb,
-  line,
-  macaddr,
-  macaddr8,
-  numeric,
-  point,
-  real,
-  smallint,
-  text,
-  time,
-  timestamp,
-  uuid,
-  varchar,
-  index,
-  uniqueIndex,
-  alias,
-  foreignKey,
-  union,
-  unionAll,
-  intersect,
-  intersectAll,
-  except,
-  exceptAll
-} from "drizzle-orm/pg-core";
-export {
-  alias,
-  and2 as and,
-  asc2 as asc,
-  avg,
-  avgDistinct,
-  between,
-  bigint,
-  boolean,
-  char,
-  cidr,
-  client,
-  count2 as count,
-  countDistinct,
-  createConfig,
-  date,
-  desc2 as desc,
-  doublePrecision,
-  eq2 as eq,
-  except,
-  exceptAll,
-  exists,
-  factory,
-  foreignKey,
-  graphql,
-  gt2 as gt,
-  gte2 as gte,
-  hex,
-  ilike,
-  inArray2 as inArray,
-  index,
-  inet,
-  bigint2 as int8,
-  integer,
-  intersect,
-  intersectAll,
-  interval,
-  isNotNull,
-  isNull,
-  json,
-  jsonb,
-  like2 as like,
-  line,
-  loadBalance,
-  lt2 as lt,
-  lte2 as lte,
-  macaddr,
-  macaddr8,
-  max,
-  mergeAbis,
-  min,
-  ne2 as ne,
-  not2 as not,
-  notBetween,
-  notExists,
-  notIlike,
-  notInArray2 as notInArray,
-  notLike2 as notLike,
-  numeric,
-  onchainEnum,
-  onchainTable,
-  or2 as or,
-  point,
-  primaryKey,
-  rateLimit,
-  real,
-  relations,
-  replaceBigInts,
-  smallint,
-  sql,
-  sum,
-  sumDistinct,
-  text,
-  time,
-  timestamp,
-  union,
-  unionAll,
-  uniqueIndex,
-  uuid,
-  varchar
-};
-//# sourceMappingURL=index.js.map