@malloy-publisher/server 0.0.382-dev → 0.2.0

package/src/dto/connection.dto.ts

@@ -1,174 +0,0 @@
-import { Type } from "class-transformer";
-import {
-   IsEnum,
-   IsNumber,
-   IsOptional,
-   IsString,
-   ValidateNested,
-} from "class-validator";
-import "reflect-metadata";
-import { ApiConnection } from "../service/model";
-
-export class PostgresConnectionDto {
-   @IsOptional()
-   @IsString()
-   host?: string;
-
-   @IsOptional()
-   @IsNumber()
-   port?: number;
-
-   @IsOptional()
-   @IsString()
-   databaseName?: string;
-
-   @IsOptional()
-   @IsString()
-   userName?: string;
-
-   @IsOptional()
-   @IsString()
-   password?: string;
-
-   @IsOptional()
-   @IsString()
-   connectionString?: string;
-}
-
-export class MysqlConnectionDto {
-   @IsOptional()
-   @IsString()
-   host?: string;
-
-   @IsOptional()
-   @IsNumber()
-   port?: number;
-
-   @IsOptional()
-   @IsString()
-   database?: string;
-
-   @IsOptional()
-   @IsString()
-   user?: string;
-
-   @IsOptional()
-   @IsString()
-   password?: string;
-}
-
-export class BigqueryConnectionDto {
-   @IsOptional()
-   @IsString()
-   defaultProjectId?: string;
-
-   @IsOptional()
-   @IsString()
-   billingProjectId?: string;
-
-   @IsOptional()
-   @IsString()
-   location?: string;
-
-   @IsOptional()
-   @IsString()
-   serviceAccountKeyJson?: string;
-
-   @IsOptional()
-   @IsString()
-   maximumBytesBilled?: string;
-
-   @IsOptional()
-   @IsString()
-   queryTimeoutMilliseconds?: string;
-}
-
-export class SnowflakeConnectionDto {
-   @IsOptional()
-   @IsString()
-   account?: string;
-
-   @IsOptional()
-   @IsString()
-   username?: string;
-
-   @IsOptional()
-   @IsString()
-   password?: string;
-
-   @IsOptional()
-   @IsString()
-   warehouse?: string;
-
-   @IsOptional()
-   @IsString()
-   database?: string;
-
-   @IsOptional()
-   @IsString()
-   schema?: string;
-
-   @IsOptional()
-   @IsNumber()
-   responseTimeoutMilliseconds?: number;
-}
-
-export class TrinoConnectionDto {
-   @IsOptional()
-   @IsString()
-   server?: string;
-
-   @IsOptional()
-   @IsString()
-   port?: number;
-
-   @IsOptional()
-   @IsString()
-   catalog?: string;
-
-   @IsOptional()
-   @IsString()
-   schema?: string;
-
-   @IsOptional()
-   @IsString()
-   user?: string;
-
-   @IsOptional()
-   @IsString()
-   password?: string;
-
-   @IsOptional()
-   @IsString()
-   peakaKey?: string;
-}
-
-export class ConnectionDto implements ApiConnection {
-   @IsOptional()
-   @IsString()
-   name?: string;
-
-   @IsOptional()
-   @IsEnum(["postgres", "bigquery", "snowflake", "trino"])
-   type?: "postgres" | "bigquery" | "snowflake" | "trino";
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => PostgresConnectionDto)
-   postgresConnection?: PostgresConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => BigqueryConnectionDto)
-   bigqueryConnection?: BigqueryConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => SnowflakeConnectionDto)
-   snowflakeConnection?: SnowflakeConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => TrinoConnectionDto)
-   TrinoConnection?: TrinoConnectionDto;
-}

package/src/dto/index.ts

@@ -1,2 +0,0 @@
-export * from "./package.dto";
-export * from "./connection.dto";

package/src/dto/package.dto.spec.ts

@@ -1,42 +0,0 @@
-import { expect, it, describe } from "bun:test";
-
-import { plainToInstance } from "class-transformer";
-import { validate } from "class-validator";
-import { PackageDto } from "./package.dto";
-import { faker } from "@faker-js/faker";
-
-describe("dto/package", () => {
-   it("should not throw when valid object is provided", async () => {
-      const errors = await validate(
-         plainToInstance(PackageDto, {
-            name: faker.person.firstName(),
-            description: faker.person.lastName(),
-         }),
-      );
-
-      expect(errors).toHaveLength(0);
-   });
-
-   it("should throw when no name is specified", async () => {
-      const errors = await validate(
-         plainToInstance(PackageDto, {
-            name: "",
-            description: faker.person.lastName(),
-         }),
-      );
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors).toHaveLength(1);
-   });
-
-   it("should throw when no description is specified", async () => {
-      const errors = await validate(
-         plainToInstance(PackageDto, {
-            name: faker.person.firstName(),
-         }),
-      );
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors).toHaveLength(1);
-   });
-});

package/src/dto/package.dto.ts

@@ -1,12 +0,0 @@
-import { IsString, IsNotEmpty } from "class-validator";
-import { ApiPackage } from "../service/package";
-
-export class PackageDto implements ApiPackage {
-   @IsString()
-   @IsNotEmpty()
-   name: string;
-
-   @IsString()
-   @IsNotEmpty()
-   description: string;
-}

package/src/dto/validate.spec.ts

@@ -1,76 +0,0 @@
-import { expect, it, describe } from "bun:test";
-import request from "supertest";
-import express from "express";
-import { validateSchema } from "./validate";
-import { PackageDto } from "./package.dto";
-import { faker } from "@faker-js/faker";
-
-const app = express();
-app.use(express.json());
-
-app.post("/packages", validateSchema(PackageDto), (req, res) => {
-   res.status(201).json({ message: "Package created", data: req.body });
-});
-
-describe("dto/validate", () => {
-   describe("validateSchema", () => {
-      it("should pass validation for a valid request", async () => {
-         const dummyPayload = {
-            name: faker.person.firstName(),
-            description: faker.person.lastName(),
-         };
-
-         const response = await request(app)
-            .post("/packages")
-            .send(dummyPayload);
-
-         expect(response.status).toBe(201);
-         expect(response.body.message).toBe("Package created");
-         expect(response.body.data).toEqual(dummyPayload);
-      });
-
-      it("should return 400 for missing required fields", async () => {
-         const response = await request(app).post("/packages").send({
-            name: "",
-            description: "",
-         });
-
-         expect(response.status).toBe(400);
-         expect(Array.isArray(response.body.errors)).toBe(true);
-
-         const expectedErrors = [
-            {
-               property: "name",
-               constraints: { isNotEmpty: "name should not be empty" },
-            },
-            {
-               property: "description",
-               constraints: {
-                  isNotEmpty: "description should not be empty",
-               },
-            },
-         ];
-         expect(response.body.errors).toEqual(
-            expect.arrayContaining(expectedErrors),
-         );
-      });
-
-      it("should return 400 for invalid description format", async () => {
-         const response = await request(app).post("/packages").send({
-            name: faker.person.firstName(),
-            description: false,
-         });
-
-         expect(response.status).toBe(400);
-         const expectedErrors = [
-            {
-               property: "description",
-               constraints: { isString: "description must be a string" },
-            },
-         ];
-         expect(response.body.errors).toEqual(
-            expect.arrayContaining(expectedErrors),
-         );
-      });
-   });
-});

package/src/dto/validate.ts

@@ -1,31 +0,0 @@
-import { Request, Response, NextFunction } from "express";
-import { plainToInstance, ClassConstructor } from "class-transformer";
-import { validate } from "class-validator";
-
-/**
- * @description validates incoming requests based on the provided dto schema
- * @param dtoClass to validate against
- * @example
- * app.post('/users', validateSchema(UserDto), (req, res) => {
- *    res.status(201).json({ message: 'User created', data: req.body });
- * });
- */
-export function validateSchema<T extends object>(
-   dtoClass: ClassConstructor<T>,
-) {
-   return async (req: Request, res: Response, next: NextFunction) => {
-      const dtoInstance = plainToInstance(dtoClass, req.body);
-      const errors = await validate(dtoInstance);
-
-      if (errors.length > 0) {
-         const formattedErrors = errors.map((err) => ({
-            property: err.property,
-            constraints: err.constraints,
-         }));
-
-         return res.status(400).json({ errors: formattedErrors });
-      }
-
-      next();
-   };
-}

package/src/errors.ts

@@ -1,116 +0,0 @@
-import { MalloyError } from "@malloydata/malloy";
-import { PUBLISHER_CONFIG_NAME } from "./constants";
-
-export function internalErrorToHttpError(error: Error) {
-   if (error instanceof BadRequestError) {
-      return httpError(400, error.message);
-   } else if (error instanceof FrozenConfigError) {
-      return httpError(403, error.message);
-   } else if (error instanceof ProjectNotFoundError) {
-      return httpError(404, error.message);
-   } else if (error instanceof PackageNotFoundError) {
-      return httpError(404, error.message);
-   } else if (error instanceof ModelNotFoundError) {
-      return httpError(404, error.message);
-   } else if (error instanceof MalloyError) {
-      return httpError(400, error.message);
-   } else if (error instanceof ConnectionNotFoundError) {
-      return httpError(404, error.message);
-   } else if (error instanceof ModelCompilationError) {
-      return httpError(424, error.message);
-   } else if (error instanceof ConnectionError) {
-      return httpError(502, error.message);
-   } else if (error instanceof MaterializationNotFoundError) {
-      return httpError(404, error.message);
-   } else if (error instanceof MaterializationConflictError) {
-      return httpError(409, error.message);
-   } else if (error instanceof InvalidStateTransitionError) {
-      return httpError(409, error.message);
-   } else {
-      return httpError(500, error.message);
-   }
-}
-
-function httpError(code: number, message: string) {
-   return {
-      status: code,
-      json: {
-         code,
-         message: message,
-      },
-   };
-}
-
-export class NotImplementedError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class BadRequestError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class ProjectNotFoundError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class PackageNotFoundError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class ModelNotFoundError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class ConnectionNotFoundError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class ConnectionError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class ModelCompilationError extends Error {
-   constructor(error: MalloyError) {
-      super(error.message);
-   }
-}
-
-export class FrozenConfigError extends Error {
-   constructor(
-      message = `Publisher config can't be updated when ${PUBLISHER_CONFIG_NAME} has { "frozenConfig": true }`,
-   ) {
-      super(message);
-   }
-}
-
-export class MaterializationNotFoundError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class MaterializationConflictError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}
-
-export class InvalidStateTransitionError extends Error {
-   constructor(message: string) {
-      super(message);
-   }
-}

package/src/health.ts

@@ -1,189 +0,0 @@
-/**
- * Health check endpoints and graceful shutdown handling.
- *
- * Provides Kubernetes-compatible health probes:
- * - /health - Overall health status
- * - /health/liveness - Always returns 200 (process is alive)
- * - /health/readiness - Returns 200 when ready, 503 when not ready
- *
- * On SIGTERM, the service enters draining state to allow in-flight requests
- * to complete before shutdown.
- */
-
-import { Express, NextFunction, Request, Response } from "express";
-import { Server } from "http";
-import { components } from "./api";
-import { shutdownSDK } from "./instrumentation";
-import { logger } from "./logger";
-export type OperationalState =
-   components["schemas"]["ServerStatus"]["operationalState"];
-
-let operationalState: OperationalState = "initializing" as OperationalState;
-let ready: boolean = false;
-let preGracefulShutdownCompleted: boolean = false;
-/**
- * Returns the current operational state of the service.
- */
-export function getOperationalState(): OperationalState {
-   return operationalState;
-}
-
-/**
- * Marks the service as ready to serve traffic.
- */
-export function markReady(): void {
-   if (operationalState !== "draining") {
-      operationalState = "serving";
-      ready = true;
-      logger.info("Service marked as ready");
-   } else {
-      logger.error("Service is already draining - cannot mark as ready");
-   }
-}
-
-/**
- * Marks the service as not ready (readiness probe will return 503).
- */
-export function markNotReady(): void {
-   ready = false;
-   logger.info("Service marked as not ready - readiness probe will fail");
-}
-
-/**
- * Registers SIGTERM handler for graceful shutdown.
- *
- * Shutdown sequence:
- * 1. Marks service as not ready (readiness probe returns 503) and enters draining state
- * 2. Waits shutdownDrainDurationSeconds to allow in-flight requests to complete
- * 3. Sets preGracefulShutdownCompleted flag (enables drainingGuard middleware to reject new requests)
- * 4. Closes main server and MCP server (stops accepting new connections)
- * 5. Closes logger
- * 6. Waits shutdownGracefulCloseTimeoutSeconds (if > 0) for final cleanup
- * 7. Exits process
- *
- * Note: drainingGuard only rejects requests after step 3 completes. During step 2,
- * the service is draining but still accepts requests (readiness probe returns 503).
- *
- * @param server - Main HTTP server instance
- * @param mcpServer - MCP server instance
- * @param shutdownDrainDurationSeconds - Duration in seconds to wait before closing servers
- * @param shutdownGracefulCloseTimeoutSeconds - Duration in seconds to wait after closing servers before exit
- */
-export function registerSignalHandlers(
-   server: Server,
-   mcpServer: Server,
-   shutdownDrainDurationSeconds: number = 0,
-   shutdownGracefulCloseTimeoutSeconds: number = 0,
-): void {
-   // Keep the process alive on SIGTERM — do not close the server.
-   // K8s will SIGKILL after terminationGracePeriodSeconds (which cannot be caught).
-   process.once("SIGTERM", async () => {
-      logger.info("========== SIGTERM RECEIVED ==========");
-      markNotReady();
-      operationalState = "draining" as OperationalState;
-      logger.info(
-         `Service entering draining state for ${shutdownDrainDurationSeconds} seconds before closing servers...`,
-      );
-
-      await new Promise((resolve) =>
-         setTimeout(() => {
-            preGracefulShutdownCompleted = true;
-            resolve(true);
-         }, shutdownDrainDurationSeconds * 1000),
-      );
-
-      const closeServer = (server: Server, name: string) =>
-         new Promise<void>((resolve) => {
-            if (server && server.listening) {
-               server.close((err) => {
-                  if (err) {
-                     logger.error(`${name} close error:`, err);
-                  } else {
-                     logger.info(`${name} closed`);
-                  }
-                  resolve();
-               });
-            } else {
-               resolve();
-            }
-         });
-
-      await Promise.all([
-         closeServer(server, "Main server"),
-         closeServer(mcpServer, "MCP server"),
-      ]);
-
-      try {
-         await shutdownSDK();
-         logger.info("OpenTelemetry SDK shut down");
-      } catch (_error) {
-         /* do nothing */
-      }
-
-      try {
-         logger.close();
-      } catch (_error) {
-         /* do nothing */
-      }
-
-      if (shutdownGracefulCloseTimeoutSeconds > 0) {
-         logger.info(
-            `Waiting ${shutdownGracefulCloseTimeoutSeconds} seconds after server close before exit...`,
-         );
-         await new Promise((resolve) =>
-            setTimeout(resolve, shutdownGracefulCloseTimeoutSeconds * 1000),
-         );
-      }
-      process.exit(0);
-   });
-}
-/**
- * Middleware that returns 503 for non-health and metrics requests when service is draining.
- * Must be registered before application routes.
- */
-export function drainingGuard(
-   req: Request,
-   res: Response,
-   next: NextFunction,
-): void {
-   if (
-      operationalState === "draining" &&
-      preGracefulShutdownCompleted &&
-      !req.path.startsWith("/health") &&
-      !req.path.startsWith("/metrics")
-   ) {
-      res.status(503).json({
-         message: "Service is draining",
-         details: "The service is shutting down and hence is not available.",
-      });
-      return;
-   }
-   next();
-}
-
-/**
- * Registers health check endpoints
- */
-export function registerHealthEndpoints(app: Express): void {
-   app.get("/health", (_req: Request, res: Response) => {
-      res.status(200).json({
-         status: "UP",
-         components: {
-            livenessState: { status: "UP" },
-            readinessState: { status: ready ? "UP" : "DOWN" },
-         },
-         groups: ["livenessState", "readinessState"],
-      });
-   });
-
-   app.get("/health/liveness", (_req: Request, res: Response) => {
-      res.status(200).json({ status: "UP" });
-   });
-
-   app.get("/health/readiness", (_req: Request, res: Response) => {
-      const isReady = ready;
-      res.status(isReady ? 200 : 503).json({
-         status: isReady ? "UP" : "DOWN",
-      });
-   });
-}