feat: project creation

Author: gregnr

package-lock.json

@@ -42,6 +42,7 @@
     "date-fns": "^4.1.0",
     "msw": "^2.7.3",
     "openapi-typescript": "^7.5.0",
+    "openapi-typescript-helpers": "^0.0.15",
     "prettier": "^3.3.3",
     "tsup": "^8.3.5",
     "tsx": "^4.19.2",

packages/mcp-server-supabase/package.json

@@ -1,4 +1,13 @@
-import createClient, { type Client, type FetchResponse } from 'openapi-fetch';
+import createClient, {
+  type Client,
+  type FetchResponse,
+  type ParseAsResponse,
+} from 'openapi-fetch';
+import type {
+  MediaType,
+  ResponseObjectMap,
+  SuccessResponse,
+} from 'openapi-typescript-helpers';
 import { z } from 'zod';
 import type { paths } from './types.js';
 
@@ -19,15 +28,29 @@ export function createManagementApiClient(
 
 export type ManagementApiClient = Client<paths>;
 
+export type SuccessResponseType<
+  T extends Record<string | number, any>,
+  Options,
+  Media extends MediaType,
+> = {
+  data: ParseAsResponse<SuccessResponse<ResponseObjectMap<T>, Media>, Options>;
+  error?: never;
+  response: Response;
+};
+
 const errorSchema = z.object({
   message: z.string(),
 });
 
-export function assertManagementApiResponse(
-  response: FetchResponse<any, any, any>,
+export function assertSuccess<
+  T extends Record<string | number, any>,
+  Options,
+  Media extends MediaType,
+>(
+  response: FetchResponse<T, Options, Media>,
   fallbackMessage: string
-) {
-  if (!response.response.ok) {
+): asserts response is SuccessResponseType<T, Options, Media> {
+  if ('error' in response) {
     if (response.response.status === 401) {
       throw new Error(
         'Unauthorized. Please provide a valid access token to the MCP server via the --access-token flag.'

packages/mcp-server-supabase/src/management-api/index.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { generatePassword } from './password.js';
+
+describe('generatePassword', () => {
+  it('should generate a password with default options', () => {
+    const password = generatePassword();
+    expect(password.length).toBe(10);
+    expect(/^[A-Za-z]+$/.test(password)).toBe(true);
+  });
+
+  it('should generate a password with custom length', () => {
+    const password = generatePassword({ length: 16 });
+    expect(password.length).toBe(16);
+  });
+
+  it('should generate a password with numbers', () => {
+    const password = generatePassword({
+      numbers: true,
+      uppercase: false,
+      lowercase: false,
+    });
+    expect(/[0-9]/.test(password)).toBe(true);
+  });
+
+  it('should generate a password with symbols', () => {
+    const password = generatePassword({ symbols: true });
+    expect(/[!@#$%^&*()_+~`|}{[\]:;?><,./-=]/.test(password)).toBe(true);
+  });
+
+  it('should generate a password with uppercase only', () => {
+    const password = generatePassword({ uppercase: true, lowercase: false });
+    expect(/^[A-Z]+$/.test(password)).toBe(true);
+  });
+
+  it('should generate a password with lowercase only', () => {
+    const password = generatePassword({ uppercase: false, lowercase: true });
+    expect(/^[a-z]+$/.test(password)).toBe(true);
+  });
+
+  it('should not generate the same password twice', () => {
+    const password1 = generatePassword();
+    const password2 = generatePassword();
+    expect(password1).not.toBe(password2);
+  });
+
+  it('should throw an error if no character sets are selected', () => {
+    expect(() =>
+      generatePassword({
+        uppercase: false,
+        lowercase: false,
+        numbers: false,
+        symbols: false,
+      })
+    ).toThrow('at least one character set must be selected');
+  });
+});

packages/mcp-server-supabase/src/password.test.ts

@@ -0,0 +1,56 @@
+const UPPERCASE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const LOWERCASE_CHARS = 'abcdefghijklmnopqrstuvwxyz';
+const NUMBER_CHARS = '0123456789';
+const SYMBOL_CHARS = '!@#$%^&*()_+~`|}{[]:;?><,./-=';
+
+export type GeneratePasswordOptions = {
+  length?: number;
+  numbers?: boolean;
+  uppercase?: boolean;
+  lowercase?: boolean;
+  symbols?: boolean;
+};
+
+/**
+ * Generates a cryptographically secure random password.
+ *
+ * @returns The generated password
+ */
+export const generatePassword = ({
+  length = 10,
+  numbers = false,
+  symbols = false,
+  uppercase = true,
+  lowercase = true,
+} = {}) => {
+  // Build the character set based on options
+  let chars = '';
+  if (uppercase) {
+    chars += UPPERCASE_CHARS;
+  }
+  if (lowercase) {
+    chars += LOWERCASE_CHARS;
+  }
+  if (numbers) {
+    chars += NUMBER_CHARS;
+  }
+  if (symbols) {
+    chars += SYMBOL_CHARS;
+  }
+
+  if (chars.length === 0) {
+    throw new Error('at least one character set must be selected');
+  }
+
+  const randomValues = new Uint32Array(length);
+  crypto.getRandomValues(randomValues);
+
+  // Map random values to our character set
+  let password = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = randomValues[i]! % chars.length;
+    password += chars.charAt(randomIndex);
+  }
+
+  return password;
+};

packages/mcp-server-supabase/src/password.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import {
+  EARTH_RADIUS,
+  getClosestAwsRegion,
+  getCountryCoordinates,
+  getDistance,
+} from './regions.js';
+
+describe('getDistance', () => {
+  it('should return 0 for the same coordinates', () => {
+    const point = { lat: 50, lng: 50 };
+    expect(getDistance(point, point)).toBe(0);
+  });
+
+  it('should calculate distance between two points correctly', () => {
+    // New York City coordinates
+    const nyc = { lat: 40.7128, lng: -74.006 };
+    // Los Angeles coordinates
+    const la = { lat: 34.0522, lng: -118.2437 };
+
+    // Approximate distance between NYC and LA is ~3940 km
+    const distance = getDistance(nyc, la);
+    expect(distance).toBeCloseTo(3940, -2); // Allow ~100km margin
+  });
+
+  it('should handle coordinates at opposite sides of the Earth', () => {
+    const point1 = { lat: 0, lng: 0 };
+    const point2 = { lat: 0, lng: 180 };
+
+    // Half circumference of Earth
+    const expectedDistance = Math.PI * EARTH_RADIUS;
+    expect(getDistance(point1, point2)).toBeCloseTo(expectedDistance, 0);
+  });
+
+  it('should handle negative coordinates', () => {
+    const sydney = { lat: -33.8688, lng: 151.2093 };
+    const buenosAires = { lat: -34.6037, lng: -58.3816 };
+
+    // Approximate distance between Sydney and Buenos Aires is ~11800 km
+    const distance = getDistance(sydney, buenosAires);
+    expect(distance).toBeCloseTo(11800, -2); // Allow ~100km margin
+  });
+
+  it('should handle coordinates at the equator', () => {
+    const point1 = { lat: 0, lng: 0 };
+    const point2 = { lat: 0, lng: 180 };
+
+    const expectedDistance = Math.PI * EARTH_RADIUS; // Half circumference
+    expect(getDistance(point1, point2)).toBeCloseTo(expectedDistance, 0);
+  });
+
+  it('should be symmetrical (a to b equals b to a)', () => {
+    const london = { lat: 51.5074, lng: -0.1278 };
+    const tokyo = { lat: 35.6762, lng: 139.6503 };
+
+    const distanceAtoB = getDistance(london, tokyo);
+    const distanceBtoA = getDistance(tokyo, london);
+
+    expect(distanceAtoB).toEqual(distanceBtoA);
+  });
+});
+
+describe('getClosestRegion', () => {
+  it('should find the closest AWS region to a specific location', async () => {
+    const tokyo = { lat: 35.6762, lng: 139.6503 };
+    const result = await getClosestAwsRegion(tokyo);
+    expect(result.code).toBe('ap-northeast-1'); // Tokyo region
+  });
+
+  it('should find the correct AWS region for European location', async () => {
+    const london = { lat: 51.5074, lng: -0.1278 };
+    const result = await getClosestAwsRegion(london);
+    expect(result.code).toBe('eu-west-2'); // London region
+  });
+
+  it('should find the correct AWS region for US West Coast location', async () => {
+    const sanFrancisco = { lat: 37.7749, lng: -122.4194 };
+    const result = await getClosestAwsRegion(sanFrancisco);
+    expect(result.code).toBe('us-west-1'); // North California region
+  });
+
+  it('should find the correct AWS region for Sydney location', async () => {
+    const sydney = { lat: -33.8688, lng: 151.2093 };
+    const result = await getClosestAwsRegion(sydney);
+    expect(result.code).toBe('ap-southeast-2'); // Sydney region
+  });
+
+  it('should find the correct AWS region for a location in South America', async () => {
+    const saoPaulo = { lat: -23.5505, lng: -46.6333 };
+    const result = await getClosestAwsRegion(saoPaulo);
+    expect(result.code).toBe('sa-east-1'); // São Paulo region
+  });
+});
+
+describe('getCountryCoordinates', () => {
+  it('should throw an error for an invalid country code', async () => {
+    const invalidCountryCode = 'INVALID_CODE';
+    expect(() => getCountryCoordinates(invalidCountryCode)).toThrowError(
+      /unknown location code/
+    );
+  });
+
+  it('should return coordinates for a valid country code', () => {
+    const result = getCountryCoordinates('US');
+    expect(result).toEqual({ lat: 38, lng: -97 });
+  });
+});