@malloy-publisher/server 0.0.226 → 0.0.228

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

@@ -1,186 +0,0 @@
-import { expect, it, describe } from "bun:test";
-
-import { plainToInstance } from "class-transformer";
-import { validate } from "class-validator";
-import {
-   BigqueryConnectionDto,
-   ConnectionDto,
-   DatabricksConnectionDto,
-   PostgresConnectionDto,
-   SnowflakeConnectionDto,
-   MysqlConnectionDto,
-} from "./connection.dto";
-
-describe("dto/connection", () => {
-   describe("Connection Validation", () => {
-      it("should validate a valid MysqlConnection object", async () => {
-         const validData = {
-            host: "localhost",
-            port: 3306,
-            database: "testdb",
-            user: "user",
-            password: "pass",
-         };
-         const mysqlConnection = plainToInstance(MysqlConnectionDto, validData);
-
-         const errors = await validate(mysqlConnection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should validate a valid PostgresConnection object", async () => {
-         const validData = {
-            host: "localhost",
-            port: 5432,
-            databaseName: "testdb",
-            userName: "user",
-            password: "pass",
-            connectionString: "postgres://user:pass@localhost:5432/testdb",
-         };
-         const postgresConnection = plainToInstance(
-            PostgresConnectionDto,
-            validData,
-         );
-
-         const errors = await validate(postgresConnection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should return errors for invalid PostgresConnection object", async () => {
-         const invalidData = {
-            host: 123, // Invalid type
-            port: "not-a-number", // Invalid type
-         };
-         const postgresConnection = plainToInstance(
-            PostgresConnectionDto,
-            invalidData,
-         );
-
-         const errors = await validate(postgresConnection);
-         expect(errors).not.toHaveLength(0);
-         expect(errors).toHaveLength(2);
-      });
-
-      it("should validate a valid BigqueryConnection object", async () => {
-         const validData = {
-            defaultProjectId: "default-project",
-            billingProjectId: "billing-project",
-            location: "US",
-            serviceAccountKeyJson: "{}",
-            maximumBytesBilled: "1000000",
-            queryTimeoutMilliseconds: "1000",
-         };
-         const bigqueryConnection = plainToInstance(
-            BigqueryConnectionDto,
-            validData,
-         );
-
-         const errors = await validate(bigqueryConnection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should validate a valid SnowflakeConnection object", async () => {
-         const validData = {
-            account: "my-account",
-            username: "user",
-            password: "pass",
-            privateKey:
-               "-----BEGIN PRIVATE KEY-----\\nabc\\n-----END PRIVATE KEY-----",
-            privateKeyPass: "secret",
-            warehouse: "my-warehouse",
-            database: "my-database",
-            schema: "my-schema",
-            role: "analyst",
-            responseTimeoutMilliseconds: 5000,
-         };
-         const snowflakeConnection = plainToInstance(
-            SnowflakeConnectionDto,
-            validData,
-         );
-
-         const errors = await validate(snowflakeConnection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should validate a valid DatabricksConnection object", async () => {
-         const validData = {
-            host: "dbc-xxxxxxxx-xxxx.cloud.databricks.com",
-            path: "/sql/1.0/warehouses/abc123",
-            token: "dapiXXXX",
-            oauthClientId: "client-id",
-            oauthClientSecret: "client-secret",
-            defaultCatalog: "main",
-            defaultSchema: "default",
-            setupSQL: "USE CATALOG main",
-         };
-         const databricksConnection = plainToInstance(
-            DatabricksConnectionDto,
-            validData,
-         );
-
-         const errors = await validate(databricksConnection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should return errors for invalid DatabricksConnection object", async () => {
-         const invalidData = {
-            host: 123, // Invalid type
-            path: false, // Invalid type
-         };
-         const databricksConnection = plainToInstance(
-            DatabricksConnectionDto,
-            invalidData,
-         );
-
-         const errors = await validate(databricksConnection);
-         expect(errors).toHaveLength(2);
-      });
-
-      it("should validate a valid Connection object with databricks type", async () => {
-         const validData = {
-            name: "My Databricks Connection",
-            type: "databricks",
-            databricksConnection: {
-               host: "dbc-xxxxxxxx-xxxx.cloud.databricks.com",
-               path: "/sql/1.0/warehouses/abc123",
-               token: "dapiXXXX",
-            },
-         };
-         const connection = plainToInstance(ConnectionDto, validData);
-
-         const errors = await validate(connection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should validate a valid Connection object with postgres type", async () => {
-         const validData = {
-            name: "My Postgres Connection",
-            type: "postgres",
-            postgresConnection: {
-               host: "localhost",
-               port: 5432,
-               databaseName: "testdb",
-               userName: "user",
-               password: "pass",
-            },
-         };
-         const connection = plainToInstance(ConnectionDto, validData);
-
-         const errors = await validate(connection);
-         expect(errors).toHaveLength(0);
-      });
-
-      it("should return errors for invalid Connection object", async () => {
-         const invalidData = {
-            type: "invalid-type", // Invalid enum value
-            postgresConnection: {
-               port: "invalid-port", // Invalid type
-            },
-         };
-         const connection = plainToInstance(ConnectionDto, invalidData);
-
-         const errors = await validate(connection);
-         expect(errors).not.toHaveLength(0);
-         expect(errors.length).toBeGreaterThan(0);
-      });
-   });
-});

package/src/dto/connection.dto.ts

@@ -1,308 +0,0 @@
-import { Type } from "class-transformer";
-import {
-   IsDefined,
-   IsEnum,
-   IsArray,
-   IsNumber,
-   IsOptional,
-   IsString,
-   ValidateIf,
-   ValidateNested,
-} from "class-validator";
-import "reflect-metadata";
-import { components } from "../api";
-import { ApiConnection } from "../service/model";
-
-type AttachedDatabase = components["schemas"]["AttachedDatabase"];
-
-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()
-   privateKey?: string;
-
-   @IsOptional()
-   @IsString()
-   privateKeyPass?: string;
-
-   @IsOptional()
-   @IsString()
-   warehouse?: string;
-
-   @IsOptional()
-   @IsString()
-   database?: string;
-
-   @IsOptional()
-   @IsString()
-   schema?: string;
-
-   @IsOptional()
-   @IsString()
-   role?: string;
-
-   @IsOptional()
-   @IsNumber()
-   responseTimeoutMilliseconds?: number;
-}
-
-export class DatabricksConnectionDto {
-   @IsOptional()
-   @IsString()
-   host?: string;
-
-   @IsOptional()
-   @IsString()
-   path?: string;
-
-   @IsOptional()
-   @IsString()
-   token?: string;
-
-   @IsOptional()
-   @IsString()
-   oauthClientId?: string;
-
-   @IsOptional()
-   @IsString()
-   oauthClientSecret?: string;
-
-   @IsOptional()
-   @IsString()
-   defaultCatalog?: string;
-
-   @IsOptional()
-   @IsString()
-   defaultSchema?: string;
-
-   @IsOptional()
-   @IsString()
-   setupSQL?: string;
-}
-
-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 DuckdbConnectionDto {
-   @IsOptional()
-   @IsArray()
-   attachedDatabases?: AttachedDatabase[];
-}
-
-export class SshProxyConfigDto {
-   @IsString()
-   host!: string;
-
-   @IsOptional()
-   @IsNumber()
-   port?: number;
-
-   @IsString()
-   username!: string;
-
-   @IsString()
-   privateKey!: string;
-
-   @IsOptional()
-   @IsString()
-   privateKeyPass?: string;
-
-   @IsOptional()
-   @IsString()
-   hostKey?: string;
-}
-
-export class ConnectionProxyDto {
-   @IsEnum(["ssh"])
-   type!: "ssh";
-
-   // ssh config is required for the ssh proxy type (the only type today); keep
-   // the conditional so a future proxy type isn't forced to supply `ssh`.
-   @ValidateIf((o) => o.type === "ssh")
-   @IsDefined()
-   @ValidateNested()
-   @Type(() => SshProxyConfigDto)
-   ssh?: SshProxyConfigDto;
-}
-
-export class ConnectionDto implements ApiConnection {
-   @IsOptional()
-   @IsString()
-   name?: string;
-
-   @IsOptional()
-   @IsEnum([
-      "postgres",
-      "bigquery",
-      "snowflake",
-      "trino",
-      "databricks",
-      "mysql",
-      "duckdb",
-      "motherduck",
-      "ducklake",
-   ])
-   type?:
-      | "postgres"
-      | "bigquery"
-      | "snowflake"
-      | "trino"
-      | "databricks"
-      | "mysql"
-      | "duckdb"
-      | "motherduck"
-      | "ducklake";
-
-   // Opaque, secret-free data-identity token; carried verbatim (never parsed
-   // or re-hashed) into content-addressed source ids. See api-doc.yaml.
-   @IsOptional()
-   @IsString()
-   fingerprint?: string;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => PostgresConnectionDto)
-   postgresConnection?: PostgresConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => BigqueryConnectionDto)
-   bigqueryConnection?: BigqueryConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => SnowflakeConnectionDto)
-   snowflakeConnection?: SnowflakeConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => TrinoConnectionDto)
-   TrinoConnection?: TrinoConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => DatabricksConnectionDto)
-   databricksConnection?: DatabricksConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => DuckdbConnectionDto)
-   duckdbConnection?: DuckdbConnectionDto;
-
-   @IsOptional()
-   @ValidateNested()
-   @Type(() => ConnectionProxyDto)
-   proxy?: ConnectionProxyDto;
-}

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,27 +0,0 @@
-import {
-   IsString,
-   IsNotEmpty,
-   IsOptional,
-   IsArray,
-   IsIn,
-} from "class-validator";
-import { ApiPackage } from "../service/package";
-
-export class PackageDto implements ApiPackage {
-   @IsString()
-   @IsNotEmpty()
-   name: string;
-
-   @IsString()
-   @IsNotEmpty()
-   description: string;
-
-   @IsOptional()
-   @IsArray()
-   @IsString({ each: true })
-   explores?: string[];
-
-   @IsOptional()
-   @IsIn(["declared", "all"])
-   queryableSources?: "declared" | "all";
-}

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();
-   };
-}