@flarequery/firebase 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,153 +1,72 @@
-// ../core/src/parser/index.ts
-var ParseError = class extends Error {
-  constructor(message, position) {
-    super(`Parse error at ${position}: ${message}`);
-    this.position = position;
-    this.name = "ParseError";
-  }
-};
-function tokenize(input) {
-  const tokens = [];
-  let i = 0;
-  while (i < input.length) {
-    if (/\s/.test(input[i]) || input[i] === ",") {
-      i++;
-      continue;
-    }
-    if (input[i] === "#") {
-      while (i < input.length && input[i] !== "\n") i++;
-      continue;
-    }
-    if (input[i] === "{") {
-      tokens.push({ kind: "lbrace", value: "{", position: i });
-      i++;
-      continue;
-    }
-    if (input[i] === "}") {
-      tokens.push({ kind: "rbrace", value: "}", position: i });
-      i++;
-      continue;
-    }
-    if (input[i] === "(") {
-      tokens.push({ kind: "lparen", value: "(", position: i });
-      i++;
-      continue;
-    }
-    if (input[i] === ")") {
-      tokens.push({ kind: "rparen", value: ")", position: i });
-      i++;
-      continue;
-    }
-    if (input[i] === ":") {
-      tokens.push({ kind: "colon", value: ":", position: i });
-      i++;
-      continue;
-    }
-    if (input[i] === '"') {
-      const start = i;
-      i++;
-      let str = "";
-      while (i < input.length && input[i] !== '"') {
-        str += input[i];
-        i++;
+// src/adapter.ts
+var FIRESTORE_GETALL_LIMIT = 300;
+function createFirestoreAdapter(db) {
+  return {
+    async getOne(collection, id, fieldMask) {
+      const ref = db.collection(collection).doc(id);
+      const snapshot = await ref.get();
+      return adaptSnapshot(snapshot, fieldMask);
+    },
+    async getMany(collection, ids, fieldMask) {
+      if (ids.length === 0) return [];
+      const chunks = chunkArray(ids, FIRESTORE_GETALL_LIMIT);
+      const chunkResults = await Promise.all(
+        chunks.map((chunk) => {
+          const refs = chunk.map((id) => db.collection(collection).doc(id));
+          return db.getAll(...refs, { fieldMask });
+        })
+      );
+      return chunkResults.flat().map((snap) => adaptSnapshot(snap, fieldMask));
+    },
+    async getCollection(collection, filters, fieldMask, orderBy, limit) {
+      let query = db.collection(collection);
+      for (const filter of filters) {
+        query = query.where(
+          filter.field,
+          filter.operator,
+          filter.value
+        );
       }
-      if (i >= input.length) throw new ParseError("unterminated string literal", start);
-      i++;
-      tokens.push({ kind: "string", value: str, position: start });
-      continue;
-    }
-    if (/[a-zA-Z_]/.test(input[i])) {
-      const start = i;
-      let word = "";
-      while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
-        word += input[i];
-        i++;
+      if (orderBy !== void 0) {
+        query = query.orderBy(orderBy.field, orderBy.direction);
+      }
+      if (limit !== void 0) {
+        query = query.limit(limit);
+      }
+      if (fieldMask.length > 0) {
+        query = query.select(...fieldMask);
       }
-      tokens.push({ kind: "word", value: word, position: start });
-      continue;
+      const snapshot = await query.get();
+      return snapshot.docs.map((snap) => adaptSnapshot(snap, fieldMask));
     }
-    throw new ParseError(`unexpected character '${input[i]}'`, i);
-  }
-  tokens.push({ kind: "eof", value: "", position: i });
-  return tokens;
+  };
 }
-var Parser = class {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.pos = 0;
-  }
-  peek() {
-    return this.tokens[this.pos];
-  }
-  consume(expectedKind) {
-    const token = this.tokens[this.pos];
-    if (expectedKind && token.kind !== expectedKind) {
-      throw new ParseError(`expected ${expectedKind}, got ${token.kind}`, token.position);
-    }
-    this.pos++;
-    return token;
-  }
-  consumeWord(expectedVal) {
-    const token = this.consume("word");
-    if (expectedVal !== void 0 && token.value !== expectedVal) {
-      throw new ParseError(`expected ${expectedVal}, got ${token.value}`, token.position);
-    }
-    return token;
-  }
-  parseQuery() {
-    if (this.peek().kind === "word" && this.peek().value === "query") {
-      this.consume("word");
-    }
-    this.consume("lbrace");
-    const node = this.parseModelSelection();
-    this.consume("rbrace");
-    if (this.peek().kind !== "eof") {
-      throw new ParseError("expected end of query", this.peek().position);
-    }
-    return node;
-  }
-  parseModelSelection() {
-    const modelToken = this.consumeWord();
-    const model = modelToken.value;
-    this.consume("lparen");
-    this.consumeWord("id");
-    this.consume("colon");
-    const idToken = this.consume("string");
-    this.consume("rparen");
-    this.consume("lbrace");
-    const selections = this.parseFieldList();
-    this.consume("rbrace");
-    return { model, id: idToken.value, selections };
-  }
-  parseFieldList() {
-    const fields = [];
-    while (this.peek().kind !== "rbrace" && this.peek().kind !== "eof") {
-      fields.push(this.parseField());
-    }
-    if (fields.length === 0) {
-      throw new ParseError("selection set cannot be empty", this.peek().position);
-    }
-    return fields;
-  }
-  parseField() {
-    const nameToken = this.consumeWord();
-    const name = nameToken.value;
-    if (this.peek().kind === "lbrace") {
-      this.consume("lbrace");
-      const children = this.parseFieldList();
-      this.consume("rbrace");
-      return { name, children };
+function adaptSnapshot(snap, fieldMask) {
+  return {
+    id: snap.id,
+    exists: snap.exists,
+    data() {
+      if (!snap.exists) return void 0;
+      const raw = snap.data() ?? {};
+      const masked = {};
+      for (const field of fieldMask) {
+        if (field in raw) {
+          masked[field] = raw[field];
+        }
+      }
+      return masked;
     }
-    return { name, children: [] };
+  };
+}
+function chunkArray(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
   }
-};
-function parseQuery(input) {
-  const token = tokenize(input);
-  const parse = new Parser(token);
-  return parse.parseQuery();
+  return chunks;
 }
 
-// ../core/src/planner/index.ts
+// ../core/dist/index.js
 var PlanError = class extends Error {
   constructor(message) {
     super(`PlanError: ${message}`);
@@ -173,13 +92,7 @@ function resolveSelections(selections, model, models, ctx, allOps) {
           `relation field '${selection.name}' must have a selection set`
         );
       }
-      const dependent = planRelationField(
-        selection,
-        fieldDef,
-        models,
-        ctx,
-        allOps
-      );
+      const dependent = planRelationField(selection, fieldDef, models, ctx, allOps);
       dependents.push(dependent);
     } else {
       scalarMask.push(selection.name);
@@ -281,8 +194,86 @@ function buildExecutionPlan(queryNode, models, ctx) {
   );
   return { root: rootOp, ops: allOps };
 }
-
-// ../core/src/executor/index.ts
+var INEQUALITY_OPS = /* @__PURE__ */ new Set(["!=", "<", "<=", ">", ">="]);
+function validateFirestoreConstraints(filters, orderBy) {
+  const inequalityFields = [
+    ...new Set(
+      filters.filter((f) => INEQUALITY_OPS.has(f.operator)).map((f) => f.field)
+    )
+  ];
+  if (inequalityFields.length > 1) {
+    throw new PlanError(
+      `Firestore only allows inequality filters (!=, <, <=, >, >=) on ONE field per query.
+You have inequality filters on: [${inequalityFields.join(", ")}].
+Fix: keep one inequality field in .filter() and handle the rest in memory after .get().`
+    );
+  }
+  if (inequalityFields.length === 1 && orderBy !== void 0 && orderBy.field !== inequalityFields[0]) {
+    throw new PlanError(
+      `Firestore requires orderBy to be on the same field as the inequality filter.`
+    );
+  }
+}
+function validateModelFields(filters, selections, model) {
+  const availableFields = Object.keys(model.fields).join(", ");
+  for (const filter of filters) {
+    const fieldDef = model.fields[filter.field];
+    if (fieldDef === void 0) {
+      throw new PlanError(
+        `filter field '${filter.field}' does not exist on model '${model.source.path}'.
+Available fields: [${availableFields}]`
+      );
+    }
+    if (typeof fieldDef === "object" && "relation" in fieldDef) {
+      throw new PlanError(
+        `Use the scalar foreign key field instead (e.g. '${fieldDef.relation.from}').`
+      );
+    }
+  }
+  for (const selection of selections) {
+    if (model.fields[selection.name] === void 0) {
+      throw new PlanError(
+        `selected field '${selection.name}' does not exist on model '${model.source.path}'.
+`
+      );
+    }
+  }
+}
+function buildCollectionPlan(queryNode, models, ctx) {
+  const model = models.get(queryNode.model);
+  if (model === void 0) {
+    throw new PlanError(`model '${queryNode.model}' is not registered`);
+  }
+  if (model.auth !== void 0 && !model.auth(ctx)) {
+    throw new PlanError(`unauthorized access to model '${queryNode.model}'`);
+  }
+  validateModelFields(queryNode.filters, queryNode.selections, model);
+  validateFirestoreConstraints(queryNode.filters, queryNode.orderBy);
+  const allOps = [];
+  const { scalarMask, dependents } = resolveSelections(
+    queryNode.selections,
+    model,
+    models,
+    ctx,
+    allOps
+  );
+  const relationForeignKeys = dependents.map((d) => d.foreignKey);
+  const fieldMask = Array.from(/* @__PURE__ */ new Set([...scalarMask, ...relationForeignKeys]));
+  const plan = {
+    collection: model.source.path,
+    fieldMask,
+    filters: queryNode.filters,
+    dependents,
+    selections: queryNode.selections
+  };
+  if (queryNode.orderBy !== void 0) {
+    plan.orderBy = queryNode.orderBy;
+  }
+  if (queryNode.limit !== void 0) {
+    plan.limit = queryNode.limit;
+  }
+  return plan;
+}
 var ExecutionError = class extends Error {
   constructor(message) {
     super(`ExecutionError: ${message}`);
@@ -364,7 +355,7 @@ async function executeOp(op, parentDoc, adapter) {
   }
   return executeGetMany(op, parentDoc, adapter);
 }
-async function executeplan(plan, adapter) {
+async function executePlan(plan, adapter) {
   try {
     const data = await executeOp(plan.root, null, adapter);
     return { data };
@@ -375,70 +366,276 @@ async function executeplan(plan, adapter) {
     throw err;
   }
 }
+async function resolveCollectionDoc(snap, plan, adapter) {
+  if (!snap.exists) return null;
+  const docData = snap.data();
+  if (docData === void 0) return null;
+  const result = await resolveDependents(plan.dependents, docData, adapter);
+  const foreignKeys = new Set(plan.dependents.map((d) => d.foreignKey));
+  for (const [key, value] of Object.entries(docData)) {
+    if (!foreignKeys.has(key) && plan.fieldMask.includes(key)) {
+      result[key] = value;
+    }
+  }
+  result.__id = snap.id;
+  return result;
+}
+async function executeCollectionPlan(plan, adapter) {
+  try {
+    const snapshots = await adapter.getCollection(
+      plan.collection,
+      plan.filters,
+      plan.fieldMask,
+      plan.orderBy,
+      plan.limit
+    );
+    const results = await Promise.all(
+      snapshots.map((snap) => resolveCollectionDoc(snap, plan, adapter))
+    );
+    const data = results.filter((r) => r !== null);
+    return { data };
+  } catch (err) {
+    if (err instanceof ExecutionError) {
+      return { data: [], errors: [err.message] };
+    }
+    throw err;
+  }
+}
 
-// src/adapter.ts
-var FIRESTORE_GETALL_LIMIT = 300;
-function createFirestoreAdapter(db) {
-  return {
-    async getOne(collection, id, fieldMask) {
-      const ref = db.collection(collection).doc(id);
-      const snapshot = await ref.get();
-      return adaptSnapshot(snapshot, fieldMask);
-    },
-    async getMany(collection, ids, fieldMask) {
-      if (ids.length === 0) return [];
-      const chunks = chunkArray(ids, FIRESTORE_GETALL_LIMIT);
-      const chunkResults = await Promise.all(
-        chunks.map((chunk) => {
-          const refs = chunk.map((id) => db.collection(collection).doc(id));
-          return db.getAll(...refs, { fieldMask });
-        })
-      );
-      return chunkResults.flat().map((snap) => adaptSnapshot(snap, fieldMask));
+// src/builder.ts
+var CollectionReferenceImpl = class {
+  constructor(modelName, models, adapter) {
+    this.modelName = modelName;
+    this.models = models;
+    this.adapter = adapter;
+  }
+  doc(id) {
+    return new DocumentReferenceImpl(
+      this.modelName,
+      id,
+      this.models,
+      this.adapter
+    );
+  }
+  filter(field) {
+    return new FilterBuilderImpl(
+      field,
+      this.modelName,
+      [],
+      [],
+      void 0,
+      void 0,
+      this.models,
+      this.adapter
+    );
+  }
+};
+var DocumentReferenceImpl = class {
+  constructor(modelName, docId, models, adapter) {
+    this.modelName = modelName;
+    this.docId = docId;
+    this.models = models;
+    this.adapter = adapter;
+  }
+  select(...fields) {
+    return new QueryImpl(
+      this.modelName,
+      this.docId,
+      fields,
+      this.models,
+      this.adapter
+    );
+  }
+};
+var QueryImpl = class {
+  constructor(modelName, docId, fields, models, adapter) {
+    this.modelName = modelName;
+    this.docId = docId;
+    this.fields = fields;
+    this.models = models;
+    this.adapter = adapter;
+  }
+  async get(ctx) {
+    const queryNode = buildQueryNode(this.modelName, this.docId, this.fields);
+    const plan = buildExecutionPlan(queryNode, this.models, ctx);
+    return executePlan(plan, this.adapter);
+  }
+};
+var FilterBuilderImpl = class {
+  constructor(field, modelName, existingFilters, selections, orderByClause, limitValue, models, adapter) {
+    this.field = field;
+    this.modelName = modelName;
+    this.existingFilters = existingFilters;
+    this.selections = selections;
+    this.orderByClause = orderByClause;
+    this.limitValue = limitValue;
+    this.models = models;
+    this.adapter = adapter;
+  }
+  next(operator, value) {
+    const newFilter = { field: this.field, operator, value };
+    return new CollectionQueryImpl(
+      this.modelName,
+      [...this.existingFilters, newFilter],
+      this.selections,
+      this.orderByClause,
+      this.limitValue,
+      this.models,
+      this.adapter
+    );
+  }
+  equals(value) {
+    return this.next("==", value);
+  }
+  not(value) {
+    return this.next("!=", value);
+  }
+  gt(value) {
+    return this.next(">", value);
+  }
+  gte(value) {
+    return this.next(">=", value);
+  }
+  lt(value) {
+    return this.next("<", value);
+  }
+  lte(value) {
+    return this.next("<=", value);
+  }
+  in(values) {
+    return this.next("in", values);
+  }
+  contains(value) {
+    return this.next("array-contains", value);
+  }
+};
+var CollectionQueryImpl = class _CollectionQueryImpl {
+  constructor(modelName, filters, selectedFields, orderByClause, limitValue, models, adapter) {
+    this.modelName = modelName;
+    this.filters = filters;
+    this.selectedFields = selectedFields;
+    this.orderByClause = orderByClause;
+    this.limitValue = limitValue;
+    this.models = models;
+    this.adapter = adapter;
+  }
+  filter(field) {
+    return new FilterBuilderImpl(
+      field,
+      this.modelName,
+      this.filters,
+      this.selectedFields,
+      this.orderByClause,
+      this.limitValue,
+      this.models,
+      this.adapter
+    );
+  }
+  select(...fields) {
+    return new _CollectionQueryImpl(
+      this.modelName,
+      this.filters,
+      fields,
+      this.orderByClause,
+      this.limitValue,
+      this.models,
+      this.adapter
+    );
+  }
+  orderBy(field, direction) {
+    return new _CollectionQueryImpl(
+      this.modelName,
+      this.filters,
+      this.selectedFields,
+      { field, direction },
+      this.limitValue,
+      this.models,
+      this.adapter
+    );
+  }
+  limit(n) {
+    return new _CollectionQueryImpl(
+      this.modelName,
+      this.filters,
+      this.selectedFields,
+      this.orderByClause,
+      n,
+      this.models,
+      this.adapter
+    );
+  }
+  async get(ctx) {
+    const queryNode = {
+      model: this.modelName,
+      filters: this.filters,
+      selections: parseFieldSelections(this.selectedFields)
+    };
+    if (this.orderByClause !== void 0) {
+      queryNode.orderBy = this.orderByClause;
     }
-  };
+    if (this.limitValue !== void 0) {
+      queryNode.limit = this.limitValue;
+    }
+    const plan = buildCollectionPlan(queryNode, this.models, ctx);
+    return executeCollectionPlan(plan, this.adapter);
+  }
+};
+function buildQueryNode(modelName, id, fields) {
+  const selections = parseFieldSelections(fields);
+  return { model: modelName, id, selections };
 }
-function adaptSnapshot(snap, fieldMask) {
-  return {
-    id: snap.id,
-    exists: snap.exists,
-    data() {
-      if (!snap.exists) return void 0;
-      const raw = snap.data() ?? {};
-      const masked = {};
-      for (const field of fieldMask) {
-        if (field in raw) {
-          masked[field] = raw[field];
-        }
+function addNestedField(parent, parts) {
+  if (parts.length === 0) return;
+  const [current, ...rest] = parts;
+  const name = current;
+  let child = parent.children.find((c) => c.name === name);
+  if (!child) {
+    child = { name, children: [] };
+    parent.children.push(child);
+  }
+  if (rest.length > 0) {
+    addNestedField(child, rest);
+  }
+}
+function parseFieldSelections(fields) {
+  const fieldMap = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    const parts = field.split(".");
+    if (parts.length === 1) {
+      const name = parts[0];
+      if (!fieldMap.has(name)) {
+        fieldMap.set(name, { name, children: [] });
       }
-      return masked;
+    } else {
+      const [root, ...rest] = parts;
+      const rootName = root;
+      if (!fieldMap.has(rootName)) {
+        fieldMap.set(rootName, { name: rootName, children: [] });
+      }
+      const rootField = fieldMap.get(rootName);
+      addNestedField(rootField, rest);
     }
-  };
-}
-function chunkArray(arr, size) {
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
   }
-  return chunks;
+  return Array.from(fieldMap.values());
+}
+function createCollectionRef(modelName, models, adapter) {
+  return new CollectionReferenceImpl(modelName, models, adapter);
 }
 
 // src/app.ts
 function createServerlessApp(options) {
-  const { firestore, auth: firebaseAuth } = options;
+  const { firestore } = options;
   const models = /* @__PURE__ */ new Map();
   const adapter = createFirestoreAdapter(firestore);
   return {
     model(name, definition) {
       if (models.has(name)) {
-        throw new Error(`model '${name}' is already registered`);
+        console.warn(`[FlareQuery] model '${name}' is already registered \u2014 skipping duplicate registration`);
       }
       models.set(name, definition);
     },
-    async execute(query, ctx) {
-      const queryNode = parseQuery(query);
-      const plan = buildExecutionPlan(queryNode, models, ctx);
-      return executeplan(plan, adapter);
+    collection(name) {
+      return createCollectionRef(name, models, adapter);
     }
   };
 }
@@ -453,7 +650,11 @@ async function extractContext(authorization, auth) {
       userId: decoded.uid,
       token: decoded
     };
-  } catch {
+  } catch (err) {
+    console.warn(
+      "[FlareQuery] extractContext: token verification failed \u2014",
+      err instanceof Error ? err.message : "unknown error"
+    );
     return { userId: null, token: null };
   }
 }
@@ -461,65 +662,105 @@ async function extractContext(authorization, auth) {
 // src/function.ts
 import * as functionsV1 from "firebase-functions/v1";
 import { onRequest } from "firebase-functions/v2/https";
+var VALID_FIELD = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function extractQueryRequest(body) {
+  if (typeof body !== "object" || body === null || !("model" in body) || !("id" in body) || !("select" in body)) return null;
+  const req = body;
+  if (typeof req.model !== "string" || typeof req.id !== "string" || !Array.isArray(req.select) || req.select.length === 0) return null;
+  const invalidField = req.select.find(
+    (f) => typeof f !== "string" || !VALID_FIELD.test(f)
+  );
+  if (invalidField !== void 0) {
+    return { error: `invalid field: "${String(invalidField)}"` };
+  }
+  return {
+    model: req.model,
+    id: req.id,
+    select: req.select
+  };
+}
+function handleCors(req, res, options) {
+  if (!options.cors) return false;
+  res.set("Access-Control-Allow-Origin", "*");
+  res.set("Access-Control-Allow-Methods", "POST");
+  res.set("Access-Control-Allow-Headers", "Authorization, Content-Type");
+  if (req.method === "OPTIONS") {
+    res.status(204).send("");
+    return true;
+  }
+  return false;
+}
 function createFunction(app, auth, options = {}) {
   return functionsV1.https.onRequest(async (req, res) => {
-    if (options.cors) {
-      res.set("Access-Control-Allow-Origin", "*");
-      res.set("Access-Control-Allow-Methods", "POST");
-      res.set("Access-Control-Allow-Headers", "Authorization, Content-Type");
-      if (req.method === "OPTIONS") {
-        res.status(204).send("");
-        return;
-      }
-    }
+    if (handleCors(req, res, options)) return;
     if (req.method !== "POST") {
       res.status(405).json({ error: "method not allowed \u2014 use POST" });
       return;
     }
-    const query = extractQuery(req.body);
-    if (query === null) {
-      res.status(400).json({ error: "request body must contain a 'query' string field" });
+    const queryReq = extractQueryRequest(req.body);
+    if (queryReq === null) {
+      res.status(400).json({
+        error: "request body must contain: { model, id, select }",
+        example: {
+          model: "Event",
+          id: "event_1",
+          select: ["title", "participants.name"]
+        }
+      });
+      return;
+    }
+    if ("error" in queryReq) {
+      res.status(400).json({ error: queryReq.error });
       return;
     }
     const ctx = await extractContext(req.headers.authorization, auth);
-    const response = await app.execute(query, ctx);
-    res.status(200).json(response);
+    try {
+      const response = await app.collection(queryReq.model).doc(queryReq.id).select(...queryReq.select).get(ctx);
+      res.status(200).json(response);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "internal server error"
+      });
+    }
   });
 }
 function createOnRequest(app, auth, options = {}) {
   return onRequest(async (req, res) => {
-    if (options.cors) {
-      res.set("Access-Control-Allow-Origin", "*");
-      res.set("Access-Control-Allow-Methods", "POST");
-      res.set("Access-Control-Allow-Headers", "Authorization, Content-Type");
-      if (req.method === "OPTIONS") {
-        res.status(204).send("");
-        return;
-      }
-    }
+    if (handleCors(req, res, options)) return;
     if (req.method !== "POST") {
       res.status(405).json({ error: "method not allowed \u2014 use POST" });
       return;
     }
-    const query = extractQuery(req.body);
-    if (query === null) {
-      res.status(400).json({ error: "request body must contain a 'query' string field" });
+    const queryReq = extractQueryRequest(req.body);
+    if (queryReq === null) {
+      res.status(400).json({
+        error: "request body must contain: { model, id, select }",
+        example: {
+          model: "Event",
+          id: "event_1",
+          select: ["title", "participants.name"]
+        }
+      });
+      return;
+    }
+    if ("error" in queryReq) {
+      res.status(400).json({ error: queryReq.error });
       return;
     }
     const ctx = await extractContext(req.headers.authorization, auth);
-    const response = await app.execute(query, ctx);
-    res.status(200).json(response);
+    try {
+      const response = await app.collection(queryReq.model).doc(queryReq.id).select(...queryReq.select).get(ctx);
+      res.status(200).json(response);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "internal server error"
+      });
+    }
   });
 }
-function extractQuery(body) {
-  if (typeof body === "string" && body.trim().length > 0) return body.trim();
-  if (typeof body === "object" && body !== null && "query" in body && typeof body["query"] === "string") {
-    return body["query"].trim();
-  }
-  return null;
-}
 export {
   createFunction,
   createOnRequest,
-  createServerlessApp
+  createServerlessApp,
+  extractContext
 };