@objectstack/objectql 9.10.0 → 10.0.0

package/dist/index.mjs

@@ -3870,7 +3870,9 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       ["$skip", "skip"],
       ["$orderby", "orderBy"],
       ["$select", "select"],
-      ["$count", "count"]
+      ["$count", "count"],
+      ["$search", "search"],
+      ["$searchFields", "searchFields"]
     ]) {
       if (options[dollar] != null && options[bare] == null) {
         options[bare] = options[dollar];
@@ -3968,6 +3970,7 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       "aggregations",
       "groupBy",
       "search",
+      "searchFields",
       "context",
       "cursor"
     ]);
@@ -6133,6 +6136,7 @@ var ObjectStackProtocolImplementation = _ObjectStackProtocolImplementation;
 
 // src/engine.ts
 import { AsyncLocalStorage } from "async_hooks";
+import { parseAutonumberFormat, renderAutonumber, missingFieldValues } from "@objectstack/spec/data";
 import { ExecutionContextSchema } from "@objectstack/spec/kernel";
 import { createLogger } from "@objectstack/core";
 import { CoreServiceName, StorageNameMapping } from "@objectstack/spec/system";
@@ -6161,6 +6165,118 @@ function collectSecretFields(schema) {
 
 // src/engine.ts
 import { pluralToSingular, ExternalWriteForbiddenError } from "@objectstack/spec/shared";
+
+// src/search-filter.ts
+var TEXTUAL_TYPES = /* @__PURE__ */ new Set(["text", "email", "phone", "url", "autonumber", "textarea", "markdown"]);
+var ENUM_TYPES = /* @__PURE__ */ new Set(["select", "status"]);
+var EXCLUDED_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "_id",
+  "created",
+  "modified",
+  "created_at",
+  "updated_at",
+  "created_by",
+  "updated_by",
+  "owner_id",
+  "organization_id",
+  "space",
+  "company_id"
+]);
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set([
+  "json",
+  "object",
+  "grid",
+  "image",
+  "file",
+  "avatar",
+  "vector",
+  "location",
+  "geometry",
+  "secret",
+  "password",
+  "encrypted",
+  "boolean",
+  "lookup",
+  "master_detail"
+]);
+function normalizeSearch(raw) {
+  if (raw == null) return { query: "" };
+  if (typeof raw === "string") return { query: raw };
+  if (typeof raw === "object") {
+    const o = raw;
+    const q = typeof o.query === "string" ? o.query : typeof o.q === "string" ? o.q : "";
+    const fields = Array.isArray(o.fields) ? o.fields : void 0;
+    return { query: q, fields };
+  }
+  return { query: "" };
+}
+function autoDefaultFields(fields, displayField) {
+  const names = Object.keys(fields).filter((f) => {
+    if (EXCLUDED_FIELDS.has(f)) return false;
+    const meta = fields[f];
+    if (!meta || meta.hidden) return false;
+    const t = meta.type;
+    if (!t) return false;
+    if (EXCLUDED_TYPES.has(t)) return false;
+    return TEXTUAL_TYPES.has(t) || ENUM_TYPES.has(t);
+  });
+  const lead = displayField && fields[displayField] ? displayField : fields.name ? "name" : fields.title ? "title" : void 0;
+  if (!lead) return names;
+  return [lead, ...names.filter((f) => f !== lead)];
+}
+function resolveSearchFields(opts) {
+  const all = opts.fields || {};
+  const declared = opts.searchableFields?.filter((f) => all[f]);
+  const allowed = declared && declared.length > 0 ? declared : autoDefaultFields(all, opts.displayField);
+  const requested = typeof opts.requestedFields === "string" ? opts.requestedFields.split(",").map((f) => f.trim()).filter(Boolean) : opts.requestedFields;
+  if (requested && requested.length > 0) {
+    const allowSet = new Set(allowed);
+    const validated = requested.filter((f) => allowSet.has(f));
+    if (validated.length > 0) return validated;
+  }
+  return allowed;
+}
+function optionValuesMatching(meta, term) {
+  if (!Array.isArray(meta.options)) return [];
+  const lc = term.toLowerCase();
+  const out = [];
+  for (const opt of meta.options) {
+    if (opt == null) continue;
+    if (typeof opt === "string") {
+      if (opt.toLowerCase().includes(lc)) out.push(opt);
+      continue;
+    }
+    const label = String(opt.label ?? opt.value ?? "");
+    if (label.toLowerCase().includes(lc)) out.push(opt.value);
+  }
+  return out;
+}
+function fieldClausesForTerm(field, term, meta) {
+  if (ENUM_TYPES.has(meta?.type ?? "")) {
+    const values = optionValuesMatching(meta, term);
+    if (values.length > 0) return [{ [field]: { $in: values } }];
+    return [{ [field]: { $contains: term } }];
+  }
+  return [{ [field]: { $contains: term } }];
+}
+function expandSearchToFilter(raw, opts) {
+  const { query, fields: requested } = normalizeSearch(raw);
+  if (!query || !query.trim()) return null;
+  const searchFields = resolveSearchFields({
+    ...opts,
+    requestedFields: requested ?? opts.requestedFields
+  });
+  if (searchFields.length === 0) return null;
+  const terms = query.trim().split(/\s+/).filter(Boolean);
+  const andClauses = terms.map((term) => ({
+    $or: searchFields.flatMap((f) => fieldClausesForTerm(f, term, opts.fields[f] || {}))
+  }));
+  if (andClauses.length === 0) return null;
+  return andClauses.length === 1 ? andClauses[0] : { $and: andClauses };
+}
+
+// src/engine.ts
 import { ExpressionEngine as ExpressionEngine3 } from "@objectstack/formula";
 import { isAggregatedViewContainer as isAggregatedViewContainer2, expandViewContainer } from "@objectstack/spec";
 
@@ -7558,8 +7674,9 @@ var _ObjectQL = class _ObjectQL {
     const tx = execCtx?.transaction !== void 0 ? execCtx.transaction : this.txStore.getStore()?.transaction;
     const hasTx = tx !== void 0;
     const hasTenant = execCtx?.tenantId !== void 0;
+    const hasTz = execCtx?.timezone !== void 0;
     const isSystem = execCtx?.isSystem === true;
-    if (!hasTx && !hasTenant && !isSystem) return base;
+    if (!hasTx && !hasTenant && !isSystem && !hasTz) return base;
     const opts = base && typeof base === "object" ? { ...base } : {};
     if (hasTx && opts.transaction === void 0) {
       opts.transaction = tx;
@@ -7567,6 +7684,9 @@ var _ObjectQL = class _ObjectQL {
     if (hasTenant && opts.tenantId === void 0) {
       opts.tenantId = execCtx.tenantId;
     }
+    if (hasTz && opts.timezone === void 0) {
+      opts.timezone = execCtx.timezone;
+    }
     if (isSystem && opts.bypassTenantAudit === void 0) {
       opts.bypassTenantAudit = true;
     }
@@ -7640,29 +7760,48 @@ var _ObjectQL = class _ObjectQL {
    * owns the value, not the client.
    *
    * In the fallback path the next value is `max(existing) + 1`, seeded once per
-   * `object.field` from the store then incremented in memory (monotonic within
-   * the process, resilient to deletions). `autonumberFormat` is honored, e.g.
-   * `CASE-{0000}` → `CASE-0042`. NOTE: this in-memory seeding is single-instance.
+   * `object.field.<scope>` from the store then incremented in memory (monotonic
+   * within the process, resilient to deletions). The shared `autonumberFormat`
+   * renderer is honored end-to-end, so date tokens (`AD{YYYYMMDD}{0000}`), field
+   * interpolation (`{island_zone}{000}`) and per-scope reset behave identically
+   * to the SQL driver's persistent sequence (#1603). NOTE: this in-memory seeding
+   * is single-instance.
    */
   async applyAutonumbers(object, record, execCtx, driverOwnsAutonumber) {
     if (driverOwnsAutonumber) return;
     const fields = this.getSchema(object)?.fields;
     if (!fields || typeof fields !== "object" || Array.isArray(fields)) return;
+    const now = /* @__PURE__ */ new Date();
+    const timezone = execCtx?.timezone;
     for (const [name, def] of Object.entries(fields)) {
       if (def?.type !== "autonumber") continue;
       const current = record[name];
       if (current != null && current !== "") continue;
-      const key = `${object}.${name}`;
-      let next = this.autonumberCounters.get(key);
-      if (next == null) next = await this.seedAutonumber(object, name, execCtx);
-      next += 1;
-      this.autonumberCounters.set(key, next);
       const fmt = def.autonumberFormat ?? def.format;
-      record[name] = this.formatAutonumber(fmt, next);
+      const tokens = parseAutonumberFormat(typeof fmt === "string" ? fmt : "");
+      const missing = missingFieldValues(tokens, record);
+      if (missing.length > 0) {
+        throw new Error(
+          `Cannot generate autonumber "${object}.${name}" (format "${fmt}"): referenced field(s) [${missing.join(", ")}] are empty on the record. Fields interpolated into an autonumber format must be set before the record is created.`
+        );
+      }
+      const probe = renderAutonumber({ tokens, seq: 0, record, now, timezone });
+      const counterKey = `${object}.${name}.${probe.scope}`;
+      let next = this.autonumberCounters.get(counterKey);
+      if (next == null) next = await this.seedAutonumber(object, name, probe.prefix, execCtx);
+      next += 1;
+      this.autonumberCounters.set(counterKey, next);
+      record[name] = renderAutonumber({ tokens, seq: next, record, now, timezone }).value;
     }
   }
-  /** Seed the autonumber counter from the current max numeric value in store. */
-  async seedAutonumber(object, field, execCtx) {
+  /**
+   * Seed the autonumber counter from the current max in store, scoped to
+   * `prefix`. With a non-empty prefix (date/field formats) only rows in the
+   * same scope count, and the counter is the digit-run immediately after the
+   * prefix; with an empty prefix (legacy fixed-prefix formats) the last digit
+   * run of the whole value is used, preserving the original behaviour.
+   */
+  async seedAutonumber(object, field, prefix, execCtx) {
     try {
       const rows = await this.find(object, {
         select: ["id", field],
@@ -7673,22 +7812,24 @@ var _ObjectQL = class _ObjectQL {
       for (const r of rows || []) {
         const v = r?.[field];
         if (v == null) continue;
-        const m = String(v).match(/(\d+)(?!.*\d)/);
-        if (m) max = Math.max(max, parseInt(m[1], 10) || 0);
+        const s = String(v);
+        if (prefix && !s.startsWith(prefix)) continue;
+        const tail = prefix ? s.slice(prefix.length) : s;
+        let digits;
+        if (prefix) {
+          const head = tail.match(/^\d+/);
+          digits = head ? head[0] : void 0;
+        } else {
+          const runs = tail.match(/\d+/g);
+          digits = runs ? runs[runs.length - 1] : void 0;
+        }
+        if (digits) max = Math.max(max, parseInt(digits, 10) || 0);
       }
       return max;
     } catch {
       return 0;
     }
   }
-  /** Apply an autonumber format like `CASE-{0000}`; default to the bare number. */
-  formatAutonumber(format, value) {
-    if (!format) return String(value);
-    const m = format.match(/\{(0+)\}/);
-    if (!m) return format.includes("{0}") ? format.replace("{0}", String(value)) : `${format}${value}`;
-    const padded = String(value).padStart(m[1].length, "0");
-    return format.replace(m[0], padded);
-  }
   /**
    * Register contribution (Manifest)
    * 
@@ -8449,11 +8590,18 @@ var _ObjectQL = class _ObjectQL {
       const uniqueIds = [...new Set(allIds)];
       if (uniqueIds.length === 0) continue;
       try {
+        const idFilter = { id: { $in: uniqueIds } };
+        const where = nestedAST.where ? { $and: [idFilter, nestedAST.where] } : idFilter;
         const relatedQuery = {
           object: referenceObject,
-          where: { id: { $in: uniqueIds } },
+          where,
           ...nestedAST.fields ? { fields: nestedAST.fields } : {},
           ...nestedAST.orderBy ? { orderBy: nestedAST.orderBy } : {}
+          // NOTE: nestedAST.limit/offset are intentionally NOT forwarded here.
+          // This path batch-loads every parent's related records in a single
+          // $in query, so a *per-parent* limit/offset can't be expressed — a
+          // global cap on the batch would silently drop records other parents
+          // need. Paginate by querying the related object directly instead.
         };
         const driver = this.getDriver(referenceObject);
         const expandOpts = this.buildDriverOptions(execCtx);
@@ -8506,11 +8654,34 @@ var _ObjectQL = class _ObjectQL {
     const driver = this.getDriver(object);
     const ast = { object, ...query };
     delete ast.context;
+    if (ast.filter != null && ast.where == null) {
+      ast.where = ast.filter;
+    }
+    delete ast.filter;
     if (ast.top != null && ast.limit == null) {
       ast.limit = ast.top;
     }
     delete ast.top;
     const _findSchema = this._registry.getObject(object);
+    {
+      const _searchRaw = ast.search ?? ast.$search;
+      if (_searchRaw != null && _findSchema?.fields) {
+        const _reqFields = ast.searchFields ?? ast.$searchFields ?? (typeof ast.search === "object" ? ast.search?.fields : void 0);
+        const _searchFilter = expandSearchToFilter(_searchRaw, {
+          fields: _findSchema.fields,
+          searchableFields: _findSchema.searchableFields,
+          requestedFields: _reqFields,
+          displayField: _findSchema.displayNameField
+        });
+        if (_searchFilter) {
+          ast.where = ast.where ? { $and: [ast.where, _searchFilter] } : _searchFilter;
+        }
+      }
+      delete ast.search;
+      delete ast.$search;
+      delete ast.searchFields;
+      delete ast.$searchFields;
+    }
     const _findFormula = planFormulaProjection(_findSchema, ast.fields);
     if (_findFormula.projected) ast.fields = _findFormula.projected;
     if (_findSchema?.fields && Array.isArray(ast.fields) && ast.fields.length > 0) {
@@ -9215,7 +9386,14 @@ var _ObjectQL = class _ObjectQL {
     const obj = this._registry.getObject(objectName);
     if (!obj) return;
     const driver = this.getDriverForObject(objectName);
-    if (!driver || typeof driver.syncSchema !== "function") return;
+    if (!driver) return;
+    if (obj.external != null) {
+      if (typeof driver.registerExternalObject === "function") {
+        await driver.registerExternalObject(obj);
+      }
+      return;
+    }
+    if (typeof driver.syncSchema !== "function") return;
     const tableName = StorageNameMapping.resolveTableName(obj);
     await driver.syncSchema(tableName, obj);
   }
@@ -10049,6 +10227,27 @@ var ObjectQLPlugin = class {
         skipped++;
         continue;
       }
+      if (obj.external != null) {
+        if (typeof driver.registerExternalObject === "function") {
+          try {
+            await driver.registerExternalObject(obj);
+            synced++;
+          } catch (e) {
+            ctx.logger.warn("Failed to register external object metadata", {
+              object: obj.name,
+              driver: driver.name,
+              error: e instanceof Error ? e.message : String(e)
+            });
+          }
+        } else {
+          ctx.logger.debug("Driver does not support registerExternalObject, skipping external object", {
+            object: obj.name,
+            driver: driver.name
+          });
+          skipped++;
+        }
+        continue;
+      }
       if (typeof driver.syncSchema !== "function") {
         ctx.logger.debug("Driver does not support syncSchema, skipping", {
           object: obj.name,