@getstrata/cli 2.2.36 → 2.2.38

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @getstrata/cli changelog
 
+## 2.2.38
+
+Qualify packed OIDC and SAML callbacks across Postgres, SQLite and MySQL. Fix explicitly non-migrating local bootstrap provisioning, dialect-safe transactional SAML replay, verified bearer ACS recipient binding, and independent SAML Response Destination validation through a maintained parser. Fix owned listener/client address mismatches with typed generated native options and optional CLI HOST, retaining default production binding. Preserve existing generated auth, production guards, compiler/runtime assertions and coverage gates; live provider and deployment qualification remain separate.
+
+## 2.2.37
+
+Fix MySQL repository entity-returning mutations with transaction-pinned readback, persisted keys/defaults, honest null and deletion outcomes, complete model event payloads and injected connection ownership. Preserve native Postgres/SQLite RETURNING and conditional affected-row metadata. Close owned generated OpenAPI and failed-job command applications on success and failure before exit; retain both command and cleanup errors. Add mandatory packaged MySQL production column-tenancy CLI and HTTP auth/SCIM acceptance with an owned DML-only account, unchanged route/spec/SDK contracts, native ORM regressions and cleanup tests. Records dogfood issues #232 and #233 without application SQL workarounds.
+
 ## 2.2.36
 
 Add a mandatory installed-package SQLite column-tenancy CLI/OpenAPI/HTTP profile, including cookie/token/JWT/Basic and repeated SCIM isolation, while preserving existing Postgres security, route inventories, compiler combinations and Docker gates. Reconcile observability/rotation trackers against shipped capabilities and remaining operational qualification.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/cli",
-  "version": "2.2.36",
+  "version": "2.2.38",
   "description": "Strata CLI: framework commands for Bun apps (dev, start, migrate, run)",
   "type": "module",
   "license": "MIT",
@@ -54,8 +54,8 @@
   ],
   "scripts": {},
   "peerDependencies": {
-    "@getstrata/bootstrap": "^2.2.36",
-    "@getstrata/core": "^2.2.36"
+    "@getstrata/bootstrap": "^2.2.38",
+    "@getstrata/core": "^2.2.38"
   },
   "publishConfig": {
     "access": "public"

package/src/commandCleanup.ts

@@ -0,0 +1,25 @@
+/** One-shot commands own only the cleanup explicitly supplied by their application. */
+async function withCommandCleanup<T>(
+  operation: () => Promise<T>,
+  close?: () => void | Promise<void>,
+): Promise<T> {
+  let result: { ok: true; value: T } | { ok: false; error: unknown };
+  try {
+    result = { ok: true, value: await operation() };
+  } catch (error) {
+    result = { ok: false, error };
+  }
+  try {
+    await close?.();
+  } catch (error) {
+    if (!result.ok)
+      throw new AggregateError([result.error, error], "Command and application cleanup failed.", {
+        cause: result.error,
+      });
+    throw error;
+  }
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+export { withCommandCleanup };

package/src/openapi.ts

@@ -6,6 +6,9 @@ import { generateOpenApiSpec, renderOpenApiDocument } from "@getstrata/core/open
 import { validateOpenApiSpec } from "@getstrata/core/openapi/validate";
 import { readSpaPrefix } from "@getstrata/core/runtime/frontendMode";
 
+import { withCommandCleanup } from "./commandCleanup.ts";
+
+type AppCleanup = () => void | Promise<void>;
 type AppBootstrap = () => Promise<{ routes: Record<string, unknown> }>;
 
 function isSpaDocumentedPath(path: string, spaPrefix: string): boolean {
@@ -62,71 +65,94 @@ async function registerAppOpenApiRoutes(bootstrap: AppBootstrap): Promise<void>
   registerOpenApiRouteMap(unregisteredKeepers, ["global", "api"]);
 }
 
-function createOpenApiGenerateCommand(bootstrap: AppBootstrap) {
-  return async function openapiGenerateCommand(): Promise<void> {
-    await registerAppOpenApiRoutes(bootstrap);
-
-    const spec = generateOpenApiSpec(routeRegistry.list());
-    const jsonPath = join(process.cwd(), "docs/openapi.json");
-    await mkdir(dirname(jsonPath), { recursive: true });
-    await writeFile(jsonPath, renderOpenApiDocument(spec), "utf8");
-
-    console.log(`OpenAPI spec written to ${jsonPath} (${routeRegistry.list().length} routes).`);
+function createOpenApiCommand(
+  bootstrap: AppBootstrap,
+  operation: () => Promise<number | undefined>,
+  close?: AppCleanup,
+) {
+  return async (): Promise<void> => {
+    const exitCode = await withCommandCleanup(async () => {
+      await registerAppOpenApiRoutes(bootstrap);
+      return operation();
+    }, close);
+    if (exitCode === 1) process.exit(1);
   };
 }
 
-function createOpenApiValidateCommand(bootstrap: AppBootstrap) {
-  return async function openapiValidateCommand(): Promise<void> {
-    await registerAppOpenApiRoutes(bootstrap);
-
-    const spec = generateOpenApiSpec(routeRegistry.list());
-    const errors = validateOpenApiSpec(spec);
+function createOpenApiGenerateCommand(bootstrap: AppBootstrap, close?: AppCleanup) {
+  return createOpenApiCommand(
+    bootstrap,
+    async () => {
+      const spec = generateOpenApiSpec(routeRegistry.list());
+      const jsonPath = join(process.cwd(), "docs/openapi.json");
+      await mkdir(dirname(jsonPath), { recursive: true });
+      await writeFile(jsonPath, renderOpenApiDocument(spec), "utf8");
+
+      console.log(`OpenAPI spec written to ${jsonPath} (${routeRegistry.list().length} routes).`);
+      return undefined;
+    },
+    close,
+  );
+}
 
-    if (errors.length > 0) {
-      console.error("OpenAPI validation failed:");
-      for (const error of errors) {
-        console.error(`- ${error}`);
+function createOpenApiValidateCommand(bootstrap: AppBootstrap, close?: AppCleanup) {
+  return createOpenApiCommand(
+    bootstrap,
+    async () => {
+      const spec = generateOpenApiSpec(routeRegistry.list());
+      const errors = validateOpenApiSpec(spec);
+
+      if (errors.length > 0) {
+        console.error("OpenAPI validation failed:");
+        for (const error of errors) {
+          console.error(`- ${error}`);
+        }
+        return 1;
       }
-      process.exit(1);
-    }
 
-    console.log(`OpenAPI spec valid (${routeRegistry.list().length} routes).`);
-  };
+      console.log(`OpenAPI spec valid (${routeRegistry.list().length} routes).`);
+      return undefined;
+    },
+    close,
+  );
 }
 
-function createOpenApiCheckCommand(bootstrap: AppBootstrap) {
-  return async function openapiCheckCommand(): Promise<void> {
-    await registerAppOpenApiRoutes(bootstrap);
-
-    const spec = generateOpenApiSpec(routeRegistry.list());
-    const errors = validateOpenApiSpec(spec);
-
-    if (errors.length > 0) {
-      console.error("OpenAPI validation failed:");
-      for (const error of errors) {
-        console.error(`- ${error}`);
+function createOpenApiCheckCommand(bootstrap: AppBootstrap, close?: AppCleanup) {
+  return createOpenApiCommand(
+    bootstrap,
+    async () => {
+      const spec = generateOpenApiSpec(routeRegistry.list());
+      const errors = validateOpenApiSpec(spec);
+
+      if (errors.length > 0) {
+        console.error("OpenAPI validation failed:");
+        for (const error of errors) {
+          console.error(`- ${error}`);
+        }
+        return 1;
       }
-      process.exit(1);
-    }
 
-    const generated = renderOpenApiDocument(spec);
-    const jsonPath = join(process.cwd(), "docs/openapi.json");
-    const committed = await readFile(jsonPath, "utf8");
-
-    if (committed !== generated) {
-      console.error("OpenAPI spec drift detected.");
-      console.error("Run `strata openapi:generate` and commit docs/openapi.json.");
-      console.error(
-        "Add that generate step next to `strata openapi:check` in CI so new routes cannot ship undocumented.",
-      );
-      process.exit(1);
-    }
+      const generated = renderOpenApiDocument(spec);
+      const jsonPath = join(process.cwd(), "docs/openapi.json");
+      const committed = await readFile(jsonPath, "utf8");
+
+      if (committed !== generated) {
+        console.error("OpenAPI spec drift detected.");
+        console.error("Run `strata openapi:generate` and commit docs/openapi.json.");
+        console.error(
+          "Add that generate step next to `strata openapi:check` in CI so new routes cannot ship undocumented.",
+        );
+        return 1;
+      }
 
-    console.log(`OpenAPI spec matches committed file (${routeRegistry.list().length} routes).`);
-  };
+      console.log(`OpenAPI spec matches committed file (${routeRegistry.list().length} routes).`);
+      return undefined;
+    },
+    close,
+  );
 }
 
-export type { AppBootstrap };
+export type { AppBootstrap, AppCleanup };
 export {
   createOpenApiCheckCommand,
   createOpenApiGenerateCommand,

package/src/queueFailed.ts

@@ -5,6 +5,7 @@ import {
 } from "@getstrata/core/queue/createAppQueue";
 import { jobRegistry } from "@getstrata/core/queue/jobRegistry";
 import { resolveApplicationQueue } from "@getstrata/core/runtime/applicationRegistry";
+import { withCommandCleanup } from "./commandCleanup.ts";
 import type { StrataCommand } from "./types.ts";
 
 type QueueFailedBoot = () => unknown | Promise<unknown>;
@@ -61,15 +62,20 @@ async function queueFlushFailedCommand(boot?: QueueFailedBoot): Promise<void> {
   console.log(`Removed ${deleted} failed job(s).`);
 }
 
-function createQueueFailedCommands(boot?: QueueFailedBoot): {
+function createQueueFailedCommands(
+  boot?: QueueFailedBoot,
+  close?: () => void | Promise<void>,
+): {
   queueFailedCommand: StrataCommand;
   queueRetryCommand: StrataCommand;
   queueFlushFailedCommand: StrataCommand;
 } {
   return {
-    queueFailedCommand: async () => queueFailedCommand(boot),
-    queueRetryCommand: async (id?: string) => queueRetryCommand(id, boot),
-    queueFlushFailedCommand: async () => queueFlushFailedCommand(boot),
+    queueFailedCommand: async () => withCommandCleanup(() => queueFailedCommand(boot), close),
+    queueRetryCommand: async (id?: string) =>
+      withCommandCleanup(() => queueRetryCommand(id, boot), close),
+    queueFlushFailedCommand: async () =>
+      withCommandCleanup(() => queueFlushFailedCommand(boot), close),
   };
 }