@sfxcode/nuxt-ui-mongocamp 1.1.0

package/dist/runtime/composables/useMongocampDynamicForm.js

@@ -0,0 +1,231 @@
+import { parseAbsoluteToLocal } from "@internationalized/date";
+const SCALAR_FORMKIT_TYPES = {
+  "string": "nuxtUIInput",
+  "number": "nuxtUIInputNumber",
+  "boolean": "nuxtUISwitch",
+  "date-time": "nuxtUIInputDate"
+};
+function scalarNode(column, formkitType) {
+  const node = {
+    $formkit: formkitType,
+    name: column.columnKey,
+    label: column.columnName
+  };
+  if (column.required) {
+    node.validation = "required";
+  }
+  return node;
+}
+function groupNode(column) {
+  return {
+    $formkit: "group",
+    name: column.columnKey,
+    label: column.columnName,
+    children: columnsToFormKitSchema(column.children ?? [])
+  };
+}
+function wrapGroup(node) {
+  return {
+    $el: "div",
+    attrs: { class: "pt-4 flex flex-col gap-3" },
+    children: [node]
+  };
+}
+function scalarArrayNode(column) {
+  const node = {
+    $formkit: "nuxtUIInputTags",
+    name: column.columnKey,
+    label: column.columnName
+  };
+  if (column.required) {
+    node.validation = "required";
+  }
+  return node;
+}
+function defaultScalarValue(formkitType) {
+  if (formkitType === "nuxtUIInputNumber") return 0;
+  if (formkitType === "nuxtUISwitch") return false;
+  return "";
+}
+function defaultValueForColumn(column) {
+  if (column.columnType === "object") return defaultObjectValue(column.children ?? []);
+  if (column.columnType === "array") return [];
+  const formkitType = SCALAR_FORMKIT_TYPES[column.columnType];
+  return formkitType ? defaultScalarValue(formkitType) : "";
+}
+function defaultObjectValue(children) {
+  const value = {};
+  children.forEach((child) => {
+    value[child.columnKey] = defaultValueForColumn(child);
+  });
+  return value;
+}
+const REPEATER_BUTTON_PROPS = {
+  alwaysDisplayInsertButton: true,
+  displayAddButton: true,
+  displayCloneButton: true,
+  displayDeleteButton: true
+};
+const REPEATER_LAYOUT_PROPS = {
+  listClass: "flex flex-col gap-3",
+  listItemClass: "flex flex-wrap items-end gap-3 p-3 border border-gray-100 dark:border-gray-800 rounded-lg shadow-sm",
+  buttonGroupClass: "flex items-center gap-1 ml-auto",
+  displayDragHandle: true,
+  draggable: true,
+  hideMoveButtons: true,
+  dragHandleClass: "cursor-grab active:cursor-grabbing text-dimmed"
+};
+function repeaterArrayNode(column, itemFormkitType) {
+  const node = {
+    $formkit: "nuxtUIRepeater",
+    name: column.columnKey,
+    label: column.columnName,
+    newItem: { value: defaultScalarValue(itemFormkitType) },
+    ...REPEATER_BUTTON_PROPS,
+    ...REPEATER_LAYOUT_PROPS,
+    children: [
+      { $formkit: itemFormkitType, name: "value", label: "Value" }
+    ]
+  };
+  if (column.required) {
+    node.validation = "required";
+  }
+  return node;
+}
+function objectArrayNode(column) {
+  const node = {
+    $formkit: "nuxtUIRepeater",
+    name: column.columnKey,
+    label: column.columnName,
+    newItem: defaultObjectValue(column.children ?? []),
+    ...REPEATER_BUTTON_PROPS,
+    ...REPEATER_LAYOUT_PROPS,
+    children: columnsToFormKitSchema(column.children ?? [])
+  };
+  if (column.required) {
+    node.validation = "required";
+  }
+  return node;
+}
+function arrayNode(column) {
+  if (column.arrayItemType === "object") {
+    return objectArrayNode(column);
+  }
+  if (column.arrayItemType === "string" || column.arrayItemType === "unknown") {
+    return scalarArrayNode(column);
+  }
+  const itemFormkitType = column.arrayItemType ? SCALAR_FORMKIT_TYPES[column.arrayItemType] : void 0;
+  if (itemFormkitType) {
+    return repeaterArrayNode(column, itemFormkitType);
+  }
+  return void 0;
+}
+export function columnsToFormKitSchema(columns) {
+  const schema = [];
+  columns.forEach((column) => {
+    if (column.columnType === "object") {
+      schema.push(wrapGroup(groupNode(column)));
+      return;
+    }
+    if (column.columnType === "array") {
+      const node = arrayNode(column);
+      if (node) schema.push(node);
+      return;
+    }
+    const formkitType = SCALAR_FORMKIT_TYPES[column.columnType];
+    if (formkitType) {
+      schema.push(scalarNode(column, formkitType));
+    }
+  });
+  return schema;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapOid(raw) {
+  if (isPlainObject(raw) && typeof raw.$oid === "string") return raw.$oid;
+  return raw;
+}
+const NUMBER_WRAPPER_KEYS = ["$numberInt", "$numberLong", "$numberDouble", "$numberDecimal"];
+function unwrapNumber(raw) {
+  if (!isPlainObject(raw)) return raw;
+  for (const key of NUMBER_WRAPPER_KEYS) {
+    const wrapped = raw[key];
+    if (typeof wrapped === "string" || typeof wrapped === "number") {
+      const parsed = Number(wrapped);
+      if (!Number.isNaN(parsed)) return parsed;
+    }
+  }
+  return raw;
+}
+function unwrapDateTime(raw) {
+  if (!isPlainObject(raw) || !("$date" in raw)) return raw;
+  const inner = raw.$date;
+  if (typeof inner === "string" || typeof inner === "number") {
+    return new Date(inner).toISOString();
+  }
+  if (isPlainObject(inner) && typeof inner.$numberLong === "string") {
+    return new Date(Number(inner.$numberLong)).toISOString();
+  }
+  return raw;
+}
+function toZonedDateTime(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return parseAbsoluteToLocal(value);
+  } catch {
+    return value;
+  }
+}
+function isZonedDateTimeLike(value) {
+  return typeof value === "object" && value !== null && typeof value.toAbsoluteString === "function";
+}
+export function documentToFormData(doc, columns) {
+  const formData = {};
+  columns.forEach((column) => {
+    if (!(column.columnKey in doc)) return;
+    const raw = doc[column.columnKey];
+    if (column.columnType === "object") {
+      if (isPlainObject(raw)) {
+        formData[column.columnKey] = documentToFormData(raw, column.children ?? []);
+      }
+      return;
+    }
+    if (column.columnType === "array") {
+      if (!Array.isArray(raw)) return;
+      formData[column.columnKey] = column.arrayItemType === "object" ? raw.map((item) => isPlainObject(item) ? documentToFormData(item, column.children ?? []) : item) : raw;
+      return;
+    }
+    if (column.columnType === "date-time") {
+      formData[column.columnKey] = toZonedDateTime(unwrapDateTime(raw));
+    } else if (column.columnType === "string") {
+      formData[column.columnKey] = unwrapOid(raw);
+    } else if (column.columnType === "number") {
+      formData[column.columnKey] = unwrapNumber(raw);
+    } else {
+      formData[column.columnKey] = raw;
+    }
+  });
+  return formData;
+}
+function wasOriginallyOid(originalValue) {
+  return isPlainObject(originalValue) && typeof originalValue.$oid === "string";
+}
+export function formDataToDocument(formData, columns, originalDoc) {
+  const result = originalDoc ? { ...originalDoc } : {};
+  columns.forEach((column) => {
+    if (!(column.columnKey in formData)) return;
+    const value = formData[column.columnKey];
+    if (column.columnType === "date-time" && isZonedDateTimeLike(value)) {
+      result[column.columnKey] = { $date: value.toAbsoluteString() };
+    } else if (column.columnType === "date-time" && typeof value === "string") {
+      result[column.columnKey] = { $date: value };
+    } else if (column.columnType === "string" && wasOriginallyOid(originalDoc?.[column.columnKey])) {
+      result[column.columnKey] = { $oid: value };
+    } else {
+      result[column.columnKey] = value;
+    }
+  });
+  delete result._id;
+  return result;
+}

package/dist/runtime/composables/useMongocampIndex.d.ts

@@ -0,0 +1,9 @@
+import type { IndexCreateResponse, IndexDropResponse, IndexOptionsRequest, MongoIndex } from '@sfxcode/nuxt-mongocamp-server';
+export declare function useMongocampIndex(): {
+    listIndexes: (collectionName: string) => Promise<MongoIndex[]>;
+    createIndex: (collectionName: string, keys: Record<string, number>, options?: IndexOptionsRequest) => Promise<IndexCreateResponse>;
+    createUniqueIndex: (collectionName: string, fieldName: string, sortAscending?: boolean) => Promise<IndexCreateResponse>;
+    createTextIndex: (collectionName: string, fieldName: string) => Promise<IndexCreateResponse>;
+    createExpiringIndex: (collectionName: string, fieldName: string, duration: string) => Promise<IndexCreateResponse>;
+    deleteIndex: (collectionName: string, indexName: string) => Promise<IndexDropResponse>;
+};

package/dist/runtime/composables/useMongocampIndex.js

@@ -0,0 +1,23 @@
+import { useMongocampApi } from "#imports";
+export function useMongocampIndex() {
+  const { indexApi } = useMongocampApi();
+  async function listIndexes(collectionName) {
+    return indexApi.listIndices({ collectionName });
+  }
+  async function createIndex(collectionName, keys, options) {
+    return indexApi.createIndex({ collectionName, indexCreateRequest: { keys, indexOptionsRequest: options } });
+  }
+  async function createUniqueIndex(collectionName, fieldName, sortAscending) {
+    return indexApi.createUniqueIndex({ collectionName, fieldName, sortAscending });
+  }
+  async function createTextIndex(collectionName, fieldName) {
+    return indexApi.createTextIndex({ collectionName, fieldName });
+  }
+  async function createExpiringIndex(collectionName, fieldName, duration) {
+    return indexApi.createExpiringIndex({ collectionName, fieldName, duration });
+  }
+  async function deleteIndex(collectionName, indexName) {
+    return indexApi.deleteIndex({ collectionName, indexName });
+  }
+  return { listIndexes, createIndex, createUniqueIndex, createTextIndex, createExpiringIndex, deleteIndex };
+}

package/dist/runtime/composables/useMongocampJobs.d.ts

@@ -0,0 +1,9 @@
+import type { JobConfig, JobInformation } from '@sfxcode/nuxt-mongocamp-server';
+export declare function useMongocampJobs(): {
+    listJobs: () => Promise<JobInformation[]>;
+    listPossibleJobs: () => Promise<string[]>;
+    registerJob: (jobConfig: JobConfig) => Promise<JobInformation>;
+    updateJob: (jobGroup: string, jobName: string, jobConfig: JobConfig) => Promise<JobInformation>;
+    executeJob: (jobGroup: string, jobName: string) => Promise<boolean>;
+    deleteJob: (jobGroup: string, jobName: string) => Promise<boolean>;
+};

package/dist/runtime/composables/useMongocampJobs.js

@@ -0,0 +1,25 @@
+import { useMongocampApi } from "#imports";
+export function useMongocampJobs() {
+  const { jobApi } = useMongocampApi();
+  async function listJobs() {
+    return jobApi.jobsList();
+  }
+  async function listPossibleJobs() {
+    return jobApi.possibleJobsList();
+  }
+  async function registerJob(jobConfig) {
+    return jobApi.registerJob({ jobConfig });
+  }
+  async function updateJob(jobGroup, jobName, jobConfig) {
+    return jobApi.updateJob({ jobGroup, jobName, jobConfig });
+  }
+  async function executeJob(jobGroup, jobName) {
+    const result = await jobApi.executeJob({ jobGroup, jobName });
+    return result.value;
+  }
+  async function deleteJob(jobGroup, jobName) {
+    const result = await jobApi.deleteJob({ jobGroup, jobName });
+    return result.value;
+  }
+  return { listJobs, listPossibleJobs, registerJob, updateJob, executeJob, deleteJob };
+}

package/dist/runtime/composables/useMongocampQuery.d.ts

@@ -0,0 +1,99 @@
+/** Scalar value accepted by all query helpers. `null` and `undefined` produce an empty (no-op) expression. */
+export type QueryValue = string | number | boolean | null | undefined;
+export interface MongocampQueryHelper {
+    /** `_exists_:fieldName` — matches documents where the field exists. */
+    exists: (fieldName: string) => string;
+    /** `-_exists_:fieldName` — matches documents where the field is absent. */
+    notExists: (fieldName: string) => string;
+    /** Alias for `notExists`. */
+    isEmpty: (fieldName: string) => string;
+    /** Alias for `exists`. */
+    isNotEmpty: (fieldName: string) => string;
+    /**
+     * `field:"value"` — exact match.
+     * Returns `''` when value is `null`, `undefined`, or an empty string.
+     */
+    equals: (fieldName: string, value: QueryValue) => string;
+    /**
+     * `-field:"value"` — excluded match.
+     * Returns `''` when value is `null`, `undefined`, or an empty string.
+     */
+    notEquals: (fieldName: string, value: QueryValue) => string;
+    /**
+     * `field:[from TO to]` — inclusive range.
+     * Pass `null` for an open-ended bound: `null` lower → `[* TO to]`, `null` upper → `[from TO *]`.
+     */
+    inRange: (fieldName: string, from: QueryValue, to: QueryValue) => string;
+    /**
+     * `-field:[from TO to]` — excluded range.
+     * Pass `null` for an open-ended bound (same semantics as `inRange`).
+     */
+    notInRange: (fieldName: string, from: QueryValue, to: QueryValue) => string;
+    /** Alias for `inRange`. */
+    between: (fieldName: string, from: QueryValue, to: QueryValue) => string;
+    /**
+     * `field:*value*` — contains substring (leading and trailing wildcard).
+     * Falls back to `field:*` when value is `null` or empty.
+     */
+    like: (fieldName: string, value: QueryValue) => string;
+    /** `-field:*value*` — does not contain substring. */
+    notLike: (fieldName: string, value: QueryValue) => string;
+    /**
+     * `field:value*` — prefix match.
+     * Falls back to `field:*` when value is `null` or empty.
+     */
+    startsWith: (fieldName: string, value: QueryValue) => string;
+    /** `-field:value*` — not a prefix match. */
+    notStartsWith: (fieldName: string, value: QueryValue) => string;
+    /**
+     * `field:*value` — suffix match (leading wildcard).
+     * Falls back to `field:*` when value is `null` or empty.
+     */
+    endsWith: (fieldName: string, value: QueryValue) => string;
+    /** `-field:*value` — not a suffix match. */
+    notEndsWith: (fieldName: string, value: QueryValue) => string;
+    /**
+     * `field:("v1" OR "v2" ...)` — matches any one of the values (OR semantics).
+     * Numbers are left unquoted; strings are quoted and escaped.
+     * Returns `''` for an empty array.
+     */
+    inClause: (fieldName: string, parameter: QueryValue[]) => string;
+    /**
+     * `-field:"v1" AND -field:"v2" ...` — excludes all listed values (AND of negations).
+     * Returns `''` for an empty array.
+     */
+    notInClause: (fieldName: string, parameter: QueryValue[]) => string;
+    /**
+     * `(field:"v1" AND field:"v2" ...)` — all values must match (AND semantics).
+     * Returns `''` for an empty array.
+     */
+    containsAll: (fieldName: string, parameter: QueryValue[]) => string;
+    /**
+     * Joins non-empty parts with `AND`, wrapping the result in `()`.
+     * Filters out `null`, `undefined`, and empty-string parts automatically.
+     * A single surviving part is returned unwrapped (no outer parens).
+     */
+    and: (...queryParts: (string | null | undefined)[]) => string;
+    /**
+     * Joins non-empty parts with `OR`, wrapping the result in `()`.
+     * Filters out `null`, `undefined`, and empty-string parts automatically.
+     * A single surviving part is returned unwrapped (no outer parens).
+     */
+    or: (...queryParts: (string | null | undefined)[]) => string;
+}
+/**
+ * High-level Lucene query helpers for MongoCamp collection filters.
+ *
+ * All helpers return a Lucene expression string. A return value of `''` means "no filter"
+ * and is safe to pass directly to `and`/`or` — they filter it out automatically.
+ *
+ * @example
+ * const h = useMongocampQuery()
+ * h.and(
+ *   h.or(h.like('name', 'alice'), h.like('email', 'alice')),
+ *   h.inClause('role', ['admin', 'user']),
+ *   h.between('createdAt', '2024-01-01', null),
+ * )
+ * // => '((name:*alice* OR email:*alice*) AND role:("admin" OR "user") AND createdAt:[2024-01-01 TO *])'
+ */
+export declare function useMongocampQuery(): MongocampQueryHelper;

package/dist/runtime/composables/useMongocampQuery.js

@@ -0,0 +1,108 @@
+import { useMongocampQueryBuilder } from "./useMongocampQueryBuilder.js";
+export function useMongocampQuery() {
+  const { q } = useMongocampQueryBuilder();
+  function exists(fieldName) {
+    return q.field("_exists_", q.phrase(fieldName));
+  }
+  function notExists(fieldName) {
+    return `-${exists(fieldName)}`;
+  }
+  function isEmpty(fieldName) {
+    return notExists(fieldName);
+  }
+  function isNotEmpty(fieldName) {
+    return exists(fieldName);
+  }
+  function equals(fieldName, value) {
+    if (value == null || value.toString().length === 0) return "";
+    return q.field(fieldName, q.terms(value.toString()));
+  }
+  function notEquals(fieldName, value) {
+    const expr = equals(fieldName, value);
+    return expr ? `-${expr}` : "";
+  }
+  function inRange(fieldName, from, to) {
+    const fromStr = from != null ? from.toString() : "*";
+    const toStr = to != null ? to.toString() : "*";
+    return q.field(fieldName, q.range(fromStr, toStr));
+  }
+  function notInRange(fieldName, from, to) {
+    return `-${inRange(fieldName, from, to)}`;
+  }
+  function between(fieldName, from, to) {
+    return inRange(fieldName, from, to);
+  }
+  function like(fieldName, value) {
+    const term = value != null && value.toString().length !== 0 ? q.phrase(`*${value}*`) : "*";
+    return q.field(fieldName, term);
+  }
+  function notLike(fieldName, value) {
+    return `-${like(fieldName, value)}`;
+  }
+  function startsWith(fieldName, value) {
+    const term = value != null && value.toString().length !== 0 ? q.phrase(`${value}*`) : "*";
+    return q.field(fieldName, term);
+  }
+  function notStartsWith(fieldName, value) {
+    return `-${startsWith(fieldName, value)}`;
+  }
+  function endsWith(fieldName, value) {
+    const term = value != null && value.toString().length !== 0 ? q.phrase(`*${value}`) : "*";
+    return q.field(fieldName, term);
+  }
+  function notEndsWith(fieldName, value) {
+    return `-${endsWith(fieldName, value)}`;
+  }
+  function toTerms(value) {
+    if (typeof value === "number") return String(value);
+    return q.terms(String(value ?? ""));
+  }
+  function inClause(fieldName, parameter) {
+    if (parameter.length === 0) return "";
+    const fields = parameter.map(toTerms);
+    const inner = fields.length === 1 ? fields[0] : `(${fields.join(" OR ")})`;
+    return q.field(fieldName, inner);
+  }
+  function notInClause(fieldName, parameter) {
+    if (parameter.length === 0) return "";
+    return and(...parameter.map((v) => notEquals(fieldName, v)));
+  }
+  function containsAll(fieldName, parameter) {
+    if (parameter.length === 0) return "";
+    return and(...parameter.map((v) => equals(fieldName, v)));
+  }
+  function logicalOperators(operator, queryParts) {
+    const parts = queryParts.filter((x) => x != null && x.length > 0 && x !== "()");
+    if (parts.length === 0) return "";
+    if (parts.length === 1) return parts[0];
+    return "(" + parts.map((x) => x.startsWith("-") ? `(${x})` : x).join(` ${operator} `) + ")";
+  }
+  function and(...queryParts) {
+    return logicalOperators("AND", queryParts);
+  }
+  function or(...queryParts) {
+    return logicalOperators("OR", queryParts);
+  }
+  return {
+    exists,
+    notExists,
+    isEmpty,
+    isNotEmpty,
+    equals,
+    notEquals,
+    inRange,
+    notInRange,
+    between,
+    like,
+    notLike,
+    startsWith,
+    notStartsWith,
+    endsWith,
+    notEndsWith,
+    inClause,
+    notInClause,
+    containsAll,
+    and,
+    or
+  };
+}

package/dist/runtime/composables/useMongocampQueryBuilder.d.ts

@@ -0,0 +1,30 @@
+declare class QueryBuilder {
+    private parts;
+    constructor(...initial: string[]);
+    field(name: string, value: string): this;
+    /** No args: insert AND connector. With args: join expressions with AND. */
+    and(...exprs: string[]): this;
+    /** No args: insert OR connector. With args: join expressions with OR. */
+    or(...exprs: string[]): this;
+    not(expr: string): this;
+    group(inner: string | QueryBuilder): this;
+    raw(expr: string): this;
+    build(): string;
+    toString(): string;
+}
+export declare function useMongocampQueryBuilder(): {
+    q: {
+        terms: (value: string) => string;
+        phrase: (value: string) => string;
+        wildcard: (pattern: string) => string;
+        fuzzy: (term: string, similarity?: number) => string;
+        proximity: (first: string, second: string, distance: number) => string;
+        range: (from: string, to: string, includeLeft?: boolean, includeRight?: boolean) => string;
+        boost: (term: string, factor: number) => string;
+        required: (term: string) => string;
+        not: (term: string) => string;
+        field: (name: string, value: string) => string;
+    };
+    Q: (...initial: string[]) => QueryBuilder;
+};
+export {};

package/dist/runtime/composables/useMongocampQueryBuilder.js

@@ -0,0 +1,112 @@
+const SPECIAL_CHARS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "&",
+  "|",
+  "!",
+  "(",
+  ")",
+  "{",
+  "}",
+  "[",
+  "]",
+  "^",
+  '"',
+  "~",
+  ":",
+  "\\",
+  "/",
+  " "
+]);
+function escape(value, wildcards = false) {
+  return [...value].map((char) => {
+    if (SPECIAL_CHARS.has(char)) return `\\${char}`;
+    if (!wildcards && (char === "*" || char === "?")) return `\\${char}`;
+    return char;
+  }).join("");
+}
+class QueryBuilder {
+  parts;
+  constructor(...initial) {
+    this.parts = initial.filter(Boolean);
+  }
+  field(name, value) {
+    this.parts.push(`${name}:${value}`);
+    return this;
+  }
+  /** No args: insert AND connector. With args: join expressions with AND. */
+  and(...exprs) {
+    if (exprs.length === 0) {
+      this.parts.push("AND");
+    } else {
+      this.parts.push(exprs.join(" AND "));
+    }
+    return this;
+  }
+  /** No args: insert OR connector. With args: join expressions with OR. */
+  or(...exprs) {
+    if (exprs.length === 0) {
+      this.parts.push("OR");
+    } else {
+      this.parts.push(exprs.join(" OR "));
+    }
+    return this;
+  }
+  not(expr) {
+    this.parts.push(`NOT ${expr}`);
+    return this;
+  }
+  group(inner) {
+    const str = typeof inner === "string" ? inner : inner.build();
+    this.parts.push(`(${str})`);
+    return this;
+  }
+  raw(expr) {
+    this.parts.push(expr);
+    return this;
+  }
+  build() {
+    return this.parts.join(" ");
+  }
+  toString() {
+    return this.build();
+  }
+}
+export function useMongocampQueryBuilder() {
+  function terms(value) {
+    if (/^-\d+$/.test(value)) return `"${value}"`;
+    return `"${escape(value)}"`;
+  }
+  function phrase(value) {
+    return escape(value, true);
+  }
+  function wildcard(pattern) {
+    return escape(pattern, true);
+  }
+  function fuzzy(term, similarity) {
+    return similarity !== void 0 ? `${term}~${similarity}` : `${term}~`;
+  }
+  function proximity(first, second, distance) {
+    return `"${first} ${second}"~${distance}`;
+  }
+  function range(from, to, includeLeft = true, includeRight = true) {
+    return `${includeLeft ? "[" : "{"}${from} TO ${to}${includeRight ? "]" : "}"}`;
+  }
+  function boost(term, factor) {
+    return `${term}^${factor}`;
+  }
+  function required(term) {
+    return `+${term}`;
+  }
+  function not(term) {
+    return `NOT ${term}`;
+  }
+  function field(name, value) {
+    return `${name}:${value}`;
+  }
+  const q = { terms, phrase, wildcard, fuzzy, proximity, range, boost, required, not, field };
+  function Q(...initial) {
+    return new QueryBuilder(...initial);
+  }
+  return { q, Q };
+}

package/dist/runtime/composables/useMongocampSchema.d.ts

@@ -0,0 +1,14 @@
+export interface ColumnDefinition {
+    columnName: string;
+    columnKey: string;
+    columnType: string;
+    required: boolean;
+    /** For columnType === 'array': the inferred type of the array elements */
+    arrayItemType?: string;
+    /** For columnType === 'object', or 'array' with arrayItemType === 'object': the inferred nested fields */
+    children?: ColumnDefinition[];
+}
+export declare function useMongocampSchema(): {
+    schemaFromSamples: (records: Array<Record<string, unknown>>) => ColumnDefinition[];
+    schemaToTsInterface: (columns: ColumnDefinition[], interfaceName: string) => string;
+};