@objectstack/objectql 7.7.0 → 7.8.0

package/dist/index.mjs

@@ -1219,6 +1219,30 @@ var SysMetadataRepository = class {
       yield header;
     }
   }
+  /**
+   * List pending DRAFT rows (ADR-0033) for this org, optionally narrowed by
+   * `type` and/or `packageId`. Unlike {@link list} (which is hard-scoped to
+   * `state='active'`), this reads `state='draft'` so the console can surface
+   * what an AI authored but a human hasn't published yet. Returns a light
+   * header projection (no body) suitable for a "pending changes" list.
+   */
+  async listDrafts(filter) {
+    this.assertOpen();
+    const where = {
+      organization_id: this.organizationId,
+      state: "draft"
+    };
+    if (filter?.type) where.type = filter.type;
+    if (filter?.packageId) where.package_id = filter.packageId;
+    const rows = await this.engine.find("sys_metadata", { where });
+    return rows.map((row) => ({
+      type: row.type,
+      name: row.name,
+      packageId: row.package_id ?? null,
+      updatedAt: row.updated_at ?? row.created_at ?? null,
+      updatedBy: row.updated_by ?? row.created_by ?? null
+    }));
+  }
   /**
    * Yield every history event for `(org, type?, name?)` from the
    * durable log, ordered by per-(type,name) `version` ascending. When
@@ -1733,6 +1757,13 @@ function resolveOverlaySchema(type, _item) {
   const singular = PLURAL_TO_SINGULAR3[type] ?? type;
   return getMetadataTypeSchema2(singular) ?? null;
 }
+function normalizeViewMetadata(type, item, saveName) {
+  const singular = PLURAL_TO_SINGULAR3[type] ?? type;
+  if (singular !== "view") return item;
+  if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+  const it = item;
+  return it.name ? it : { ...it, name: saveName };
+}
 function mergeArtifactProtection(item, artifactItem) {
   if (item === void 0 || item === null) return item;
   if (artifactItem === void 0 || artifactItem === null) return item;
@@ -3769,6 +3800,24 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       );
     }
   }
+  /**
+   * Ensure a just-PUBLISHED object's physical table exists so it is usable
+   * for data CRUD immediately — without a server restart. Registering the
+   * object (above) only updates the in-memory registry; the table is created
+   * by the driver's schema sync, which otherwise only runs at boot. Without
+   * this, inserting into a freshly-published object fails with "no such
+   * table" (surfaced as `object_not_found`) until the next restart.
+   * Best-effort + non-fatal: drivers without DDL (or read-only datasources)
+   * simply no-op, and a sync failure must not abort the publish.
+   */
+  async ensureObjectStorage(type, name) {
+    if (type !== "object" && type !== "objects") return;
+    try {
+      await this.engine.syncObjectSchema(name);
+    } catch (err) {
+      console.warn(`[Protocol] table sync failed for object '${name}': ${err?.message ?? err}`);
+    }
+  }
   async saveMetaItem(request) {
     if (!request.item) {
       throw new Error("Item data is required");
@@ -3842,6 +3891,7 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
         throw err;
       }
     }
+    request.item = normalizeViewMetadata(request.type, request.item, request.name);
     {
       const schema = resolveOverlaySchema(request.type, request.item);
       if (schema) {
@@ -3896,6 +3946,7 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
         });
         if (mode === "publish") {
           this.applyObjectRegistryMutation(request);
+          await this.ensureObjectStorage(request.type, request.name);
         }
         await this.recordMetadataAudit({
           type: request.type,
@@ -4066,6 +4117,7 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
         name: request.name,
         item: result.item.body
       });
+      await this.ensureObjectStorage(request.type, request.name);
       return {
         success: true,
         version: result.version,
@@ -4086,6 +4138,66 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       throw err;
     }
   }
+  /**
+   * List pending DRAFT metadata (ADR-0033) for the org, optionally narrowed
+   * by `packageId` and/or `type`. The list reads of `getMetaItems` only see
+   * the ACTIVE registry; this exposes what an AI authored but a human hasn't
+   * published yet, so the console can show a "pending changes" surface and a
+   * just-built app package isn't displayed as empty. No body is returned.
+   */
+  async listDrafts(request) {
+    await this.ensureOverlayIndex();
+    const orgId = request?.organizationId ?? null;
+    const repo = this.getOverlayRepo(orgId);
+    const drafts = await repo.listDrafts({
+      ...request?.type ? { type: PLURAL_TO_SINGULAR3[request.type] ?? request.type } : {},
+      ...request?.packageId ? { packageId: request.packageId } : {}
+    });
+    return { drafts };
+  }
+  /**
+   * Publish every pending DRAFT bound to a package in one shot (ADR-0033) —
+   * the "publish whole app" action. Promotes each draft→active by reusing the
+   * per-item {@link publishMetaItem} primitive (which runs the overridable /
+   * lock guards and refreshes the runtime registry), so this needs NO
+   * `metadata` service (unlike `MetadataService.publishPackage`, which reads
+   * the in-memory registry and 503s when that service is absent). Per-item
+   * failures are collected and do NOT abort the rest.
+   */
+  async publishPackageDrafts(request) {
+    await this.ensureOverlayIndex();
+    const orgId = request.organizationId ?? null;
+    const repo = this.getOverlayRepo(orgId);
+    const drafts = await repo.listDrafts({ packageId: request.packageId });
+    const published = [];
+    const failed = [];
+    for (const d of drafts) {
+      try {
+        const r = await this.publishMetaItem({
+          type: d.type,
+          name: d.name,
+          ...request.organizationId ? { organizationId: request.organizationId } : {},
+          ...request.actor ? { actor: request.actor } : {},
+          message: `publish app package '${request.packageId}'`
+        });
+        published.push({ type: d.type, name: d.name, version: r.version });
+      } catch (e) {
+        failed.push({
+          type: d.type,
+          name: d.name,
+          error: e?.message ?? "publish failed",
+          ...e?.code ? { code: e.code } : {}
+        });
+      }
+    }
+    return {
+      success: failed.length === 0 && published.length > 0,
+      publishedCount: published.length,
+      failedCount: failed.length,
+      published,
+      failed
+    };
+  }
   /**
    * Restore the body recorded at history `toVersion` as the new
    * live row. Writes a history event with `op='revert'`. 404
@@ -4623,6 +4735,39 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
     const unsubscribed = await svc.unsubscribe(request.object, request.recordId, "current_user");
     return { success: true, data: { object: request.object, recordId: request.recordId, unsubscribed } };
   }
+  /**
+   * Install a package from a manifest — the single canonical write primitive
+   * for the package subsystem (ADR-0033 consolidation).
+   *
+   * It writes BOTH stores that the runtime keeps for packages, so a package
+   * surfaces consistently no matter which read path is used:
+   *   1. the in-memory `SchemaRegistry` (what the dispatcher's
+   *      `/api/v1/packages` list/detail and `getMetaItems({type:'package'})`
+   *      read — i.e. what Studio's package selector shows), and
+   *   2. the durable `sys_packages` table via the optional `package` service
+   *      (so the package survives a restart; that service re-hydrates these
+   *      rows back into the registry on boot).
+   *
+   * The DB write is best-effort and non-fatal: when the `package` service is
+   * absent (e.g. the `marketplace` capability is off) the package is still
+   * registered in-memory and visible for the lifetime of the process.
+   */
+  async installPackage(request) {
+    const manifest = request.manifest;
+    const pkg = this.engine.registry.installPackage(manifest, request.settings);
+    try {
+      const services = this.getServicesRegistry?.();
+      const pkgSvc = services?.get("package");
+      if (pkgSvc?.publish && manifest?.version) {
+        await pkgSvc.publish({ manifest, metadata: {} });
+      }
+    } catch (e) {
+      console.warn(
+        `[protocol.installPackage] sys_packages persist skipped for '${manifest?.id}': ${e?.message}`
+      );
+    }
+    return { package: pkg, message: `Installed package: ${manifest?.id}` };
+  }
 };
 /**
  * Metadata types that are customer-overridable via {@link saveMetaItem}/
@@ -7417,6 +7562,23 @@ var _ObjectQL = class _ObjectQL {
       }
     }
   }
+  /**
+   * Sync a SINGLE object's physical storage (create/alter its table) on
+   * demand. Boot-time {@link syncSchemas} runs once at startup, so an object
+   * that becomes live at runtime (e.g. publishing a drafted object) has a
+   * registry entry but no table — data CRUD then fails with "no such table"
+   * until the next restart. Calling this right after the object is registered
+   * makes it immediately usable. Idempotent: the SQL driver only creates the
+   * table when absent (and alters to add new columns).
+   */
+  async syncObjectSchema(objectName) {
+    const obj = this._registry.getObject(objectName);
+    if (!obj) return;
+    const driver = this.getDriverForObject(objectName);
+    if (!driver || typeof driver.syncSchema !== "function") return;
+    const tableName = StorageNameMapping.resolveTableName(obj);
+    await driver.syncSchema(tableName, obj);
+  }
   /**
    * Get a registered driver by datasource name.
    * Alias matching @objectql/core datasource() API.