@malloy-publisher/server 0.0.235 → 0.0.237

package/src/service/connection_service.ts

@@ -1,291 +0,0 @@
-import { components } from "../api";
-import { ConnectionNotFoundError, FrozenConfigError } from "../errors";
-import { logger } from "../logger";
-import { buildEnvironmentMalloyConfig } from "./connection";
-import { EnvironmentStore } from "./environment_store";
-
-type ApiConnection = components["schemas"]["Connection"];
-type ReleaseCallback = () => Promise<void>;
-type ConnectionUpdateEnvironment = {
-   runConnectionUpdateExclusive?: <T>(fn: () => Promise<T>) => Promise<T>;
-   updateConnections?: (
-      nextMalloyConfig: ReturnType<typeof buildEnvironmentMalloyConfig>,
-      apiConnections?: ApiConnection[],
-      afterPreviousRelease?: ReleaseCallback,
-   ) => void;
-   deleteConnection?: (connectionName: string) => Promise<void>;
-   deleteDuckDBConnection?: (connectionName: string) => Promise<void>;
-   deleteDuckLakeConnection?: (connectionName: string) => Promise<void>;
-};
-
-async function runEnvironmentConnectionUpdate<T>(
-   environment: ConnectionUpdateEnvironment,
-   fn: () => Promise<T>,
-): Promise<T> {
-   if (environment.runConnectionUpdateExclusive) {
-      return environment.runConnectionUpdateExclusive(fn);
-   }
-   return fn();
-}
-
-function updateEnvironmentConnections(
-   environment: ConnectionUpdateEnvironment,
-   nextMalloyConfig: ReturnType<typeof buildEnvironmentMalloyConfig>,
-   afterPreviousRelease?: ReleaseCallback,
-): void {
-   environment.updateConnections?.(
-      nextMalloyConfig,
-      nextMalloyConfig.apiConnections,
-      afterPreviousRelease,
-   );
-}
-
-function buildDeletedConnectionCleanup(
-   environment: ConnectionUpdateEnvironment,
-   deletedConnection: ApiConnection,
-   connectionName: string,
-): ReleaseCallback | undefined {
-   if (
-      deletedConnection.type === "duckdb" &&
-      typeof environment.deleteDuckDBConnection === "function"
-   ) {
-      return () => environment.deleteDuckDBConnection!(connectionName);
-   }
-
-   if (
-      deletedConnection.type === "ducklake" &&
-      typeof environment.deleteDuckLakeConnection === "function"
-   ) {
-      return () => environment.deleteDuckLakeConnection!(connectionName);
-   }
-
-   return undefined;
-}
-
-export class ConnectionService {
-   private environmentStore: EnvironmentStore;
-
-   constructor(environmentStore: EnvironmentStore) {
-      this.environmentStore = environmentStore;
-   }
-
-   public async getConnection(environmentName: string, connectionName: string) {
-      await this.environmentStore.finishedInitialization;
-
-      const repository = this.environmentStore.storageManager.getRepository();
-      const dbEnvironment =
-         await repository.getEnvironmentByName(environmentName);
-
-      if (!dbEnvironment) {
-         throw new Error(
-            `Environment "${environmentName}" not found in database`,
-         );
-      }
-
-      const dbConnection = await repository.getConnectionByName(
-         dbEnvironment.id,
-         connectionName,
-      );
-
-      if (!dbConnection) {
-         throw new ConnectionNotFoundError(
-            `Connection "${connectionName}" not found in environment "${environmentName}"`,
-         );
-      }
-
-      return { dbEnvironment, dbConnection, repository };
-   }
-
-   public async addConnection(
-      environmentName: string,
-      connectionName: string,
-      connection: ApiConnection,
-   ): Promise<void> {
-      await this.environmentStore.finishedInitialization;
-
-      if (this.environmentStore.publisherConfigIsFrozen) {
-         throw new FrozenConfigError();
-      }
-
-      logger.info(
-         `Adding connection "${connectionName}" to environment "${environmentName}"`,
-      );
-
-      // Get database environment record and repository
-      const repository = this.environmentStore.storageManager.getRepository();
-      const dbEnvironment =
-         await repository.getEnvironmentByName(environmentName);
-
-      if (!dbEnvironment) {
-         throw new Error(
-            `Environment "${environmentName}" not found in database`,
-         );
-      }
-
-      // Check if connection already exists in database
-      const existingDbConn = await repository.getConnectionByName(
-         dbEnvironment.id,
-         connectionName!,
-      );
-
-      if (existingDbConn) {
-         throw new Error(
-            `Connection "${connectionName}" already exists in environment "${environmentName}".`,
-         );
-      }
-
-      // Update in-memory connections
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      await runEnvironmentConnectionUpdate(environment, async () => {
-         const existingConnections = environment.listApiConnections();
-         const nextMalloyConfig = buildEnvironmentMalloyConfig(
-            [...existingConnections, connection],
-            environment.metadata.location || "",
-         );
-
-         await this.environmentStore.addConnection(
-            connection,
-            dbEnvironment.id,
-            repository,
-         );
-
-         updateEnvironmentConnections(environment, nextMalloyConfig);
-      });
-
-      logger.info(
-         `Successfully added connection "${connection.name}" to environment "${environmentName}"`,
-      );
-   }
-
-   public async updateConnection(
-      environmentName: string,
-      connectionName: string,
-      connection: Partial<ApiConnection>,
-   ): Promise<void> {
-      await this.environmentStore.finishedInitialization;
-
-      if (this.environmentStore.publisherConfigIsFrozen) {
-         throw new FrozenConfigError();
-      }
-
-      logger.info(
-         `Updating connection "${connectionName}" in environment "${environmentName}"`,
-      );
-
-      const { dbEnvironment, dbConnection, repository } =
-         await this.getConnection(environmentName, connectionName);
-
-      // Update in-memory connections
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      await runEnvironmentConnectionUpdate(environment, async () => {
-         const existingConnections = environment.listApiConnections();
-
-         const updatedConnection = {
-            ...dbConnection.config,
-            ...connection,
-            name: connectionName,
-         };
-
-         const updatedConnections = existingConnections.map(
-            (conn: ApiConnection) =>
-               conn.name === connectionName ? updatedConnection : conn,
-         );
-
-         // Pass isUpdateConnectionRequest=true so the DuckLake wrapper
-         // re-attaches against the updated catalog/storage settings instead
-         // of trusting the prior generation's persisted attach state.
-         const nextMalloyConfig = buildEnvironmentMalloyConfig(
-            updatedConnections,
-            environment.metadata.location || "",
-            true,
-         );
-
-         await this.environmentStore.updateConnection(
-            updatedConnection,
-            dbEnvironment.id,
-            repository,
-         );
-
-         updateEnvironmentConnections(environment, nextMalloyConfig);
-      });
-
-      logger.info(
-         `Successfully updated connection "${connectionName}" in environment "${environmentName}"`,
-      );
-   }
-
-   public async deleteConnection(
-      environmentName: string,
-      connectionName: string,
-   ): Promise<void> {
-      await this.environmentStore.finishedInitialization;
-
-      if (this.environmentStore.publisherConfigIsFrozen) {
-         throw new FrozenConfigError();
-      }
-
-      logger.info(
-         `Deleting connection "${connectionName}" from environment "${environmentName}"`,
-      );
-
-      const { dbConnection, repository } = await this.getConnection(
-         environmentName,
-         connectionName,
-      );
-
-      // Update in-memory connections
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      await runEnvironmentConnectionUpdate(environment, async () => {
-         if (typeof environment.listApiConnections !== "function") {
-            if (typeof environment.deleteConnection === "function") {
-               await environment.deleteConnection(connectionName);
-            }
-            await repository.deleteConnection(dbConnection.id);
-            return;
-         }
-
-         const deletedConnection =
-            "getApiConnection" in environment &&
-            typeof environment.getApiConnection === "function"
-               ? environment.getApiConnection(connectionName)
-               : dbConnection.config;
-         const updatedConnections = environment
-            .listApiConnections()
-            .filter(
-               (connection: ApiConnection) =>
-                  connection.name !== connectionName,
-            );
-         const nextMalloyConfig = buildEnvironmentMalloyConfig(
-            updatedConnections,
-            environment.metadata.location || "",
-         );
-         const deleteConnectionFilesAfterRelease =
-            buildDeletedConnectionCleanup(
-               environment,
-               deletedConnection,
-               connectionName,
-            );
-
-         await repository.deleteConnection(dbConnection.id);
-
-         updateEnvironmentConnections(
-            environment,
-            nextMalloyConfig,
-            deleteConnectionFilesAfterRelease,
-         );
-      });
-
-      logger.info(
-         `Successfully deleted connection "${connectionName}" from environment "${environmentName}"`,
-      );
-   }
-}

package/src/service/cron_evaluator.spec.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { CronEvaluator } from "./cron_evaluator";
-
-describe("CronEvaluator", () => {
-   const cron = new CronEvaluator();
-
-   describe("isValid", () => {
-      it("accepts 5-field UNIX crons", () => {
-         expect(cron.isValid("0 6 * * *")).toBe(true);
-         expect(cron.isValid("*/15 * * * *")).toBe(true);
-         expect(cron.isValid("0 0 1 1 *")).toBe(true);
-      });
-
-      it("rejects a 6-field (seconds) cron — the contract is 5-field", () => {
-         expect(cron.isValid("0 0 6 * * *")).toBe(false);
-      });
-
-      it("rejects garbage and empty input", () => {
-         expect(cron.isValid("not a cron")).toBe(false);
-         expect(cron.isValid("")).toBe(false);
-         expect(cron.isValid("* * *")).toBe(false);
-         // Out-of-range field.
-         expect(cron.isValid("99 * * * *")).toBe(false);
-      });
-
-      it("rejects cron-parser / Quartz extensions the UNIX parser lacks", () => {
-         // These parse under cron-parser but the control plane's cron-utils
-         // UNIX parser rejects them — pinning the grammar keeps a cron from
-         // validating locally yet silently never arming in production.
-         expect(cron.isValid("0 6 L * *")).toBe(false); // last day of month
-         expect(cron.isValid("0 6 15W * *")).toBe(false); // nearest weekday
-         expect(cron.isValid("0 6 * * 1#2")).toBe(false); // 2nd Monday
-         expect(cron.isValid("0 0 ? * *")).toBe(false); // Quartz no-specific
-         expect(cron.isValid("0 6 LW * *")).toBe(false); // last weekday
-      });
-
-      it("accepts UNIX month/day names (not mistaken for extensions)", () => {
-         expect(cron.isValid("0 6 * JUL *")).toBe(true); // JUL contains 'L'
-         expect(cron.isValid("0 6 * * WED")).toBe(true); // WED contains 'W'
-         expect(cron.isValid("0 6 * * THU")).toBe(true); // THU contains 'H'
-         expect(cron.isValid("0 6 * * MON-FRI")).toBe(true);
-      });
-   });
-
-   describe("nextAfter (UTC, strictly after)", () => {
-      it("returns the next daily fire", () => {
-         const from = new Date("2026-07-13T00:00:00Z");
-         expect(cron.nextAfter("0 6 * * *", from).toISOString()).toBe(
-            "2026-07-13T06:00:00.000Z",
-         );
-      });
-
-      it("rolls to the next day when the fire time has passed", () => {
-         const from = new Date("2026-07-13T07:00:00Z");
-         expect(cron.nextAfter("0 6 * * *", from).toISOString()).toBe(
-            "2026-07-14T06:00:00.000Z",
-         );
-      });
-
-      it("advances strictly past a `from` that lands exactly on a fire", () => {
-         const from = new Date("2026-07-13T06:00:00Z");
-         // Strictly after: the 06:00 instant itself is excluded.
-         expect(cron.nextAfter("0 6 * * *", from).toISOString()).toBe(
-            "2026-07-14T06:00:00.000Z",
-         );
-      });
-
-      it("steps every 15 minutes", () => {
-         const from = new Date("2026-07-13T09:07:00Z");
-         expect(cron.nextAfter("*/15 * * * *", from).toISOString()).toBe(
-            "2026-07-13T09:15:00.000Z",
-         );
-      });
-
-      it("throws on an invalid cron (callers guard with isValid)", () => {
-         expect(() => cron.nextAfter("nope", new Date())).toThrow();
-      });
-   });
-});

package/src/service/cron_evaluator.ts

@@ -1,105 +0,0 @@
-/**
- * Evaluate a 5-field UNIX cron expression, in UTC, for the standalone
- * materialization scheduler. Mirrors the control plane's `CronEvaluator`
- * semantics (5-field, UTC, "strictly after") so a given `materialization.schedule`
- * fires at the same instants whether the publisher runs standalone or the control
- * plane drives it.
- *
- * Thin wrapper over `cron-parser` that pins three policies:
- *   - **exactly 5 fields** — `cron-parser` also accepts an optional leading
- *     seconds field (6 fields); the manifest contract is 5-field UNIX cron, so a
- *     6-field expression is rejected rather than silently reinterpreted.
- *   - **plain UNIX grammar** — `cron-parser` accepts extensions (`L` last,
- *     `W` nearest-weekday, `#` nth-weekday, `?` Quartz no-specific) that the
- *     control plane's `cron-utils` UNIX parser rejects. Without this pin, an
- *     expression like `0 6 L * *` would validate and fire locally but, after
- *     publish, silently never arm in production. Month/day names (JAN, MON-FRI)
- *     are still allowed.
- *   - **UTC** — schedules are absolute, never tied to the server's local zone.
- */
-import { CronExpressionParser } from "cron-parser";
-
-/** Valid 3-letter month and day-of-week names in UNIX cron. */
-const UNIX_CRON_NAMES = new Set([
-   "JAN",
-   "FEB",
-   "MAR",
-   "APR",
-   "MAY",
-   "JUN",
-   "JUL",
-   "AUG",
-   "SEP",
-   "OCT",
-   "NOV",
-   "DEC",
-   "SUN",
-   "MON",
-   "TUE",
-   "WED",
-   "THU",
-   "FRI",
-   "SAT",
-]);
-
-export class CronEvaluator {
-   /** True when `expr` is a syntactically valid 5-field UNIX cron. */
-   isValid(expr: string): boolean {
-      if (!this.hasFiveFields(expr) || !this.isPlainUnixGrammar(expr)) {
-         return false;
-      }
-      try {
-         CronExpressionParser.parse(expr, { tz: "UTC" });
-         return true;
-      } catch {
-         return false;
-      }
-   }
-
-   /**
-    * The next fire instant strictly after `from` (UTC). Throws when `expr` is
-    * not a valid 5-field cron — callers guard with {@link isValid} (the
-    * scheduler skips + logs an invalid cron rather than letting it throw in the
-    * tick).
-    */
-   nextAfter(expr: string, from: Date): Date {
-      if (!this.hasFiveFields(expr) || !this.isPlainUnixGrammar(expr)) {
-         throw new Error(
-            `Expected a 5-field UNIX cron, got: ${JSON.stringify(expr)}`,
-         );
-      }
-      return CronExpressionParser.parse(expr, {
-         currentDate: from,
-         tz: "UTC",
-      })
-         .next()
-         .toDate();
-   }
-
-   /** Whitespace-split field count is exactly 5. */
-   private hasFiveFields(expr: string): boolean {
-      return typeof expr === "string" && expr.trim().split(/\s+/).length === 5;
-   }
-
-   /**
-    * Reject cron-parser / Quartz extensions absent from plain UNIX cron: `#`
-    * and `?` (never part of a name), and any alphabetic token that is not a
-    * UNIX month/day name — which catches `L`, `W`, `LW`, `L-3`, `15W`, etc.
-    * while still allowing named fields like `JUL` or `MON-FRI`.
-    */
-   private isPlainUnixGrammar(expr: string): boolean {
-      for (const field of expr.trim().split(/\s+/)) {
-         if (/[#?]/.test(field)) return false;
-         for (const token of field.split(/[,\-/]/)) {
-            if (token === "" || token === "*") continue;
-            if (
-               /[A-Za-z]/.test(token) &&
-               !UNIX_CRON_NAMES.has(token.toUpperCase())
-            ) {
-               return false;
-            }
-         }
-      }
-      return true;
-   }
-}