@objectstack/core 15.1.1 → 16.0.0-rc.0

package/dist/index.cjs

@@ -60,6 +60,7 @@ __export(index_exports, {
   SecurePluginContext: () => SecurePluginContext,
   SemanticVersionManager: () => SemanticVersionManager,
   ServiceLifecycle: () => ServiceLifecycle,
+  bucketKeyToCalendarRange: () => bucketKeyToCalendarRange,
   buildPermissionsFromGrants: () => buildPermissionsFromGrants,
   bulkWrite: () => bulkWrite,
   calendarPartsInTz: () => calendarPartsInTz,
@@ -105,7 +106,8 @@ __export(index_exports, {
   verifyPluginArtifact: () => verifyPluginArtifact,
   verifyPublisherSignature: () => verifyPublisherSignature,
   wireAuthoredTranslationSync: () => wireAuthoredTranslationSync,
-  withTransientRetry: () => withTransientRetry
+  withTransientRetry: () => withTransientRetry,
+  zonedDateStartToUtcMs: () => zonedDateStartToUtcMs
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -343,8 +345,34 @@ var LEVEL_COLORS = {
   silent: ""
 };
 var RESET = "\x1B[0m";
+function colorEnabled(stream) {
+  if (typeof process !== "undefined") {
+    const noColor = process.env?.NO_COLOR;
+    if (noColor !== void 0 && noColor !== "") return false;
+  }
+  return Boolean(stream?.isTTY);
+}
+function loadNodeBuiltin(id) {
+  if (typeof process === "undefined") return void 0;
+  const getBuiltinModule = process.getBuiltinModule;
+  if (typeof getBuiltinModule === "function") {
+    try {
+      return getBuiltinModule.call(process, `node:${id}`);
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    return require(id);
+  } catch {
+    return void 0;
+  }
+}
 var ObjectLogger = class _ObjectLogger {
   constructor(config = {}, bindings = {}) {
+    /** Only the logger that opened the stream may close it — children share it. */
+    this.ownsFileStream = false;
+    this.fileLoggingDisabled = false;
     this.config = {
       name: config.name,
       level: config.level ?? "info",
@@ -360,12 +388,41 @@ var ObjectLogger = class _ObjectLogger {
     }
   }
   openFileStream(path) {
+    const fs = loadNodeBuiltin("fs");
+    const nodePath2 = loadNodeBuiltin("path");
+    if (!fs || !nodePath2) {
+      this.disableFileLogging(path, "no filesystem access in this runtime");
+      return;
+    }
     try {
-      const fs = require("fs");
-      const dir = require("path").dirname(path);
-      fs.mkdirSync(dir, { recursive: true });
-      this.fileStream = fs.createWriteStream(path, { flags: "a" });
-    } catch {
+      fs.mkdirSync(nodePath2.dirname(path), { recursive: true });
+      const stream = fs.createWriteStream(path, { flags: "a" });
+      stream.on("error", (err) => this.disableFileLogging(path, err.message));
+      this.fileStream = stream;
+      this.ownsFileStream = true;
+    } catch (err) {
+      this.disableFileLogging(path, err.message);
+    }
+  }
+  /**
+   * Report — once — that an explicitly configured `file` destination is not
+   * being written, and stop trying.
+   *
+   * Deliberately not routed through `write()`: this says the logger cannot
+   * honour its own config, so `level` must not filter it. The bare `catch {}`
+   * this replaces is exactly how #3110 stayed hidden.
+   */
+  disableFileLogging(path, reason) {
+    this.fileStream = void 0;
+    this.ownsFileStream = false;
+    if (this.fileLoggingDisabled) return;
+    this.fileLoggingDisabled = true;
+    const label = this.config.name ? `[${this.config.name}] ` : "";
+    const notice = `${label}logger: file logging disabled \u2014 cannot write to ${path}: ${reason}`;
+    if (typeof process !== "undefined" && process.stderr) {
+      process.stderr.write(notice + "\n");
+    } else if (typeof console !== "undefined") {
+      console.warn(notice);
     }
   }
   isEnabled(level) {
@@ -393,9 +450,13 @@ var ObjectLogger = class _ObjectLogger {
     });
     const hasContext = Object.keys(context).length > 0;
     const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const isErrorLevel = level === "error" || level === "fatal";
+    const proc = typeof process !== "undefined" ? process : void 0;
+    const stream = proc ? isErrorLevel ? proc.stderr : proc.stdout : void 0;
     let line;
+    let plainLine;
     if (this.config.format === "json") {
-      line = JSON.stringify({
+      line = plainLine = JSON.stringify({
         time: ts,
         level,
         ...this.config.name ? { name: this.config.name } : {},
@@ -405,26 +466,24 @@ var ObjectLogger = class _ObjectLogger {
     } else if (this.config.format === "text") {
       const parts = [ts, level.toUpperCase(), message];
       if (hasContext) parts.push(JSON.stringify(context));
-      line = parts.join(" | ");
+      line = plainLine = parts.join(" | ");
     } else {
-      const color = LEVEL_COLORS[level] || "";
       const label = this.config.name ? `[${this.config.name}] ` : "";
-      line = `${color}${ts} ${level.toUpperCase()}${RESET} ${label}${message}`;
-      if (hasContext) line += ` ${JSON.stringify(context)}`;
+      const head = `${ts} ${level.toUpperCase()}`;
+      let tail = ` ${label}${message}`;
+      if (hasContext) tail += ` ${JSON.stringify(context)}`;
+      plainLine = head + tail;
+      const color = LEVEL_COLORS[level] || "";
+      line = color && colorEnabled(stream) ? `${color}${head}${RESET}${tail}` : plainLine;
     }
-    const out = line + "\n";
-    if (typeof process !== "undefined" && process.stderr) {
-      if (level === "error" || level === "fatal") {
-        process.stderr.write(out);
-      } else {
-        process.stdout?.write(out);
-      }
+    if (stream) {
+      stream.write(line + "\n");
     } else if (typeof console !== "undefined") {
       const fn = level === "error" || level === "fatal" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log;
       fn(line);
     }
     if (this.fileStream) {
-      this.fileStream.write(out);
+      this.fileStream.write(plainLine + "\n");
     }
   }
   debug(message, meta) {
@@ -454,7 +513,8 @@ var ObjectLogger = class _ObjectLogger {
     this.info(message, args.length > 0 ? { args } : void 0);
   }
   child(context) {
-    const child = new _ObjectLogger(this.config, { ...this.bindings, ...context });
+    const child = new _ObjectLogger({ ...this.config, file: void 0 }, { ...this.bindings, ...context });
+    child.config.file = this.config.file;
     child.fileStream = this.fileStream;
     return child;
   }
@@ -462,10 +522,11 @@ var ObjectLogger = class _ObjectLogger {
     return this.child({ traceId, spanId });
   }
   async destroy() {
-    if (this.fileStream) {
-      await new Promise((resolve) => this.fileStream.end(resolve));
-      this.fileStream = void 0;
-    }
+    const stream = this.fileStream;
+    this.fileStream = void 0;
+    if (!stream || !this.ownsFileStream) return;
+    this.ownsFileStream = false;
+    await new Promise((resolve) => stream.end(resolve));
   }
 };
 function createLogger(config) {
@@ -1713,6 +1774,19 @@ var ObjectKernel = class {
   getPluginMetrics() {
     return new Map(this.pluginStartTimes);
   }
+  /**
+   * Whether a plugin with the given name has been registered on this kernel.
+   *
+   * Registration happens synchronously in `use()` before any plugin's
+   * `start()` runs, so a plugin may use this during its own start() to make
+   * composition-dependent decisions deterministically — e.g. the dispatcher
+   * bridge cedes `${prefix}/discovery` to `com.objectstack.rest.api` when
+   * both are mounted (ADR-0076 D11: single owner per route, not
+   * first-registration-wins).
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
   /**
    * Get a service (sync helper)
    */
@@ -4591,6 +4665,105 @@ function calendarPartsInTzOrUtc(d, tz) {
     day: d.getUTCDate()
   };
 }
+function zonedDateStartToUtcMs(ymd, tz) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(ymd);
+  const wallAsUtc = m ? Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])) : NaN;
+  if (!tz || tz === "UTC" || Number.isNaN(wallAsUtc)) return wallAsUtc;
+  try {
+    const offsetAt = (t) => {
+      const p = new Intl.DateTimeFormat("en-US", {
+        timeZone: tz,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }).formatToParts(new Date(t));
+      const g = (k) => Number(p.find((x) => x.type === k)?.value);
+      return Date.UTC(g("year"), g("month") - 1, g("day"), g("hour"), g("minute"), g("second")) - t;
+    };
+    const off1 = offsetAt(wallAsUtc - offsetAt(wallAsUtc));
+    return wallAsUtc - off1;
+  } catch {
+    return wallAsUtc;
+  }
+}
+function isoWeekLabelUtc(d) {
+  const target = new Date(d.getTime());
+  const dayNum = (target.getUTCDay() + 6) % 7;
+  target.setUTCDate(target.getUTCDate() - dayNum + 3);
+  const firstThursday = new Date(Date.UTC(target.getUTCFullYear(), 0, 4));
+  const weekNo = 1 + Math.round(
+    ((target.getTime() - firstThursday.getTime()) / 864e5 - 3 + (firstThursday.getUTCDay() + 6) % 7) / 7
+  );
+  return `${target.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function bucketKeyToCalendarRange(key, granularity) {
+  if (typeof key !== "string" || key.length === 0) return null;
+  const fmt = (dt) => `${String(dt.getUTCFullYear()).padStart(4, "0")}-${String(dt.getUTCMonth() + 1).padStart(
+    2,
+    "0"
+  )}-${String(dt.getUTCDate()).padStart(2, "0")}`;
+  switch (granularity) {
+    case "year": {
+      const m = /^(\d{4})$/.exec(key);
+      if (!m) return null;
+      const y = Number(m[1]);
+      return { start: fmt(new Date(Date.UTC(y, 0, 1))), end: fmt(new Date(Date.UTC(y + 1, 0, 1))) };
+    }
+    case "quarter": {
+      const m = /^(\d{4})-Q([1-4])$/.exec(key);
+      if (!m) return null;
+      const y = Number(m[1]);
+      const startMonth = (Number(m[2]) - 1) * 3;
+      return {
+        start: fmt(new Date(Date.UTC(y, startMonth, 1))),
+        end: fmt(new Date(Date.UTC(y, startMonth + 3, 1)))
+        // Date.UTC rolls Q4 into next year
+      };
+    }
+    case "month": {
+      const m = /^(\d{4})-(\d{2})$/.exec(key);
+      if (!m) return null;
+      const mo = Number(m[2]);
+      if (mo < 1 || mo > 12) return null;
+      const y = Number(m[1]);
+      return {
+        start: fmt(new Date(Date.UTC(y, mo - 1, 1))),
+        end: fmt(new Date(Date.UTC(y, mo, 1)))
+      };
+    }
+    case "day": {
+      const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(key);
+      if (!m) return null;
+      const y = Number(m[1]);
+      const mo = Number(m[2]);
+      const d = Number(m[3]);
+      const start = new Date(Date.UTC(y, mo - 1, d));
+      if (fmt(start) !== key) return null;
+      return { start: key, end: fmt(new Date(Date.UTC(y, mo - 1, d + 1))) };
+    }
+    case "week": {
+      const m = /^(\d{4})-W(\d{2})$/.exec(key);
+      if (!m) return null;
+      const isoYear = Number(m[1]);
+      const week = Number(m[2]);
+      if (week < 1 || week > 53) return null;
+      const jan4 = new Date(Date.UTC(isoYear, 0, 4));
+      const jan4Dow = (jan4.getUTCDay() + 6) % 7;
+      const start = new Date(jan4.getTime());
+      start.setUTCDate(jan4.getUTCDate() - jan4Dow + (week - 1) * 7);
+      if (isoWeekLabelUtc(start) !== key) return null;
+      const end = new Date(start.getTime());
+      end.setUTCDate(start.getUTCDate() + 7);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    default:
+      return null;
+  }
+}
 
 // src/utils/bulk-write.ts
 var DEFAULT_BATCH_SIZE = 200;
@@ -4608,11 +4781,23 @@ var TRANSIENT_PATTERNS = [
   /too many connections/i
 ];
 var TRANSIENT_CODES = /^(ECONNRESET|ECONNREFUSED|ECONNABORTED|EPIPE|EAI_AGAIN|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|ENOTFOUND)$/i;
+var NON_TRANSIENT_PATTERNS = [
+  /validation/i,
+  /constraint/i,
+  /\brequired\b/i,
+  /\bunique\b/i,
+  /duplicate/i,
+  /not[\s_-]*null/i,
+  /invalid/i,
+  /not allowed/i,
+  /out of range/i
+];
 function defaultIsTransientError(err) {
-  const code = err?.code;
-  if (typeof code === "string" && TRANSIENT_CODES.test(code)) return true;
   const message = err?.message;
   const text = typeof message === "string" ? message : String(err ?? "");
+  if (NON_TRANSIENT_PATTERNS.some((re) => re.test(text))) return false;
+  const code = err?.code;
+  if (typeof code === "string" && TRANSIENT_CODES.test(code)) return true;
   return TRANSIENT_PATTERNS.some((re) => re.test(text));
 }
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -4620,7 +4805,7 @@ async function withRetry(fn, opts) {
   let lastError;
   for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
     try {
-      return await fn();
+      return await fn(attempt);
     } catch (err) {
       lastError = err;
       if (attempt >= opts.maxRetries || !opts.isTransientError(err)) throw err;
@@ -4650,7 +4835,31 @@ async function bulkWrite(rows, opts) {
   for (let start = 0; start < rows.length; start += batchSize) {
     const batch = rows.slice(start, start + batchSize);
     try {
-      const records = await withRetry(() => opts.writeBatch(batch), retryOpts);
+      if (opts.writeBatchPartial) {
+        const outcomes = await withRetry((attempt) => opts.writeBatchPartial(batch, { attempt }), retryOpts);
+        if (!Array.isArray(outcomes) || outcomes.length !== batch.length) {
+          throw Object.assign(
+            new Error(
+              `bulkWrite: writeBatchPartial returned ${Array.isArray(outcomes) ? `${outcomes.length} outcome(s)` : String(typeof outcomes)} for a ${batch.length}-row batch \u2014 treating batch as failed`
+            ),
+            { code: "ERR_BULK_RESULT_MISMATCH" }
+          );
+        }
+        for (let i = 0; i < batch.length; i++) {
+          const o = outcomes[i];
+          results[start + i] = o.ok ? { index: start + i, ok: true, record: o.record } : { index: start + i, ok: false, error: o.error };
+        }
+        continue;
+      }
+      const records = await withRetry((attempt) => opts.writeBatch(batch, { attempt }), retryOpts);
+      if (!Array.isArray(records) || records.length !== batch.length) {
+        throw Object.assign(
+          new Error(
+            `bulkWrite: writeBatch returned ${Array.isArray(records) ? `${records.length} record(s)` : String(typeof records)} for a ${batch.length}-row batch \u2014 treating batch as failed`
+          ),
+          { code: "ERR_BULK_RESULT_MISMATCH" }
+        );
+      }
       for (let i = 0; i < batch.length; i++) {
         results[start + i] = { index: start + i, ok: true, record: records[i] };
       }
@@ -4662,7 +4871,7 @@ async function bulkWrite(rows, opts) {
       for (let i = 0; i < batch.length; i++) {
         const idx = start + i;
         try {
-          const record = await withRetry(() => opts.writeOne(batch[i]), retryOpts);
+          const record = await withRetry((attempt) => opts.writeOne(batch[i], { attempt }), retryOpts);
           results[idx] = { index: idx, ok: true, record };
         } catch (err) {
           results[idx] = { index: idx, ok: false, error: err };
@@ -5618,6 +5827,7 @@ var NamespaceResolver = class {
   SecurePluginContext,
   SemanticVersionManager,
   ServiceLifecycle,
+  bucketKeyToCalendarRange,
   buildPermissionsFromGrants,
   bulkWrite,
   calendarPartsInTz,
@@ -5663,6 +5873,7 @@ var NamespaceResolver = class {
   verifyPluginArtifact,
   verifyPublisherSignature,
   wireAuthoredTranslationSync,
-  withTransientRetry
+  withTransientRetry,
+  zonedDateStartToUtcMs
 });
 //# sourceMappingURL=index.cjs.map