awilix integration

.gitignore

@@ -1,8 +1,8 @@
-.postgres-*
+.postgres-data
 .tool-versions
 .env
 .envrc
 .swc
 node_modules
 
-dist
+dist

README.md

@@ -1,62 +0,0 @@
-# Multi tenancy sketches
-
-This project is a synthetic test project for implementing multi tenancy.
-Its a functional graphql api backend, that is easiest to access from the apollo graphql explorer.
-The api and the explorer are available by default at `http://localhost:4000` by default,
-after the app and its dependencies have been started
-
-## Project setup
-
-This project is using [`pnpm`](https://pnpm.io/) as its package manager.
-To start the required databases or other dependencies, run `docker compose up -d`
-
-## About Postgres setup
-
-I had to change the `wal_level` on my local postgres instances
-it is done with running the SQL command below, and restating the database server:
-
-```sql
-ALTER SYSTEM SET wal_level = logical;
-```
-
-Note: Postgres subscriptions (which we use) in the same db server don't work that easily; easiest way to get things going is to set up multiple db servers locally.
-
-## Project description
-
-The app has these basic concepts:
-
-### User
-
-A user of the system (obviously). User authn is not implemented, authz is very simplified.
-
-### Resource
-
-This is an abstract object representing a project, that multiple users might work on.
-The notion of work on is currently implemented as the comment create action.
-A resource might belong to an organization or belong to the default (null) organization.
-
-### Comment
-
-A text note, that belongs to a given resource, created by a user.
-
-### Region
-
-A geo-located data storage region, currently implemented as a PostgresSQL database server.
-When providing a connection url to a region, make sure to not include a database name or any trailing `/`-s in the url.
-
-### Organization
-
-A collection of users and an owner of resource. Any user may create organizations.
-Organizations may be granted access to any given region. That action creates a new database in the region DB server. migrates it to the latest DB schema and sets up user and resource publish and subscribe mechanisms.
-
-## Steps to flex this POC
-
-Using the exposed graphql explorer, you can go ahead and
-- create a user 
-- create an organisation
-- add the user to the organisation
-- create regions & associate them with an organisation
-- create a resource in the default organisation, or for a specific organisation & region
-- etc.
-
-  

docker-compose.yml

@@ -1,35 +1,40 @@
 version: "3.9"
 
 services:
-  postgres:
+  maindb:
     image: postgres:16-alpine
     ports:
       - 5454:5432
-    volumes:
-      - ./.postgres-data:/var/lib/postgresql/data
     environment:
       - POSTGRES_PASSWORD=speckle
       - POSTGRES_USER=speckle
       - POSTGRES_DB=speckle_main
 
-  region-1:
+  eu_db:
     image: postgres:16-alpine
     ports:
-      - 5455:5432
-    volumes:
-      - ./.postgres-region-1:/var/lib/postgresql/data
+      - 5455:5433
     environment:
       - POSTGRES_PASSWORD=speckle
       - POSTGRES_USER=speckle
-      - POSTGRES_DB=speckle_main
+      - POSTGRES_DB=speckle_eu
+      - PGPORT=5433
 
-  region-2:
+  us_db:
     image: postgres:16-alpine
     ports:
-      - 5456:5432
-    volumes:
-      - ./.postgres-region-2:/var/lib/postgresql/data
+      - 5456:5434
     environment:
       - POSTGRES_PASSWORD=speckle
       - POSTGRES_USER=speckle
-      - POSTGRES_DB=speckle_main
+      - POSTGRES_DB=speckle_us
+      - PGPORT=5434
+
+  start_dependencies:
+    image: ducktors/docker-wait-for-dependencies
+    depends_on:
+      - maindb
+      - eu_db
+      - us_db
+    container_name: wait-for-dependencies
+    command: maindb:5432 eu_db:5433 us_db:5434

package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "src/app.ts",
   "scripts": {
-    "test": "vitest",
+    "test": "echo \"Error: no test specified\" && exit 1",
     "lint": "ts-standard",
     "tsx": "tsx",
     "lint:fix": "ts-standard --fix",
@@ -12,7 +12,7 @@
     "dev:old": "nodemon --ext ts,graphql --exec node --inspect -r @swc/register src/bin/www.ts",
     "build": "tsc",
     "start": "node dist/app.js",
-    "dev": "nodemon src/app.ts"
+    "dev": "docker compose up start_dependencies && tsx src/app.ts"
   },
   "keywords": [],
   "author": "",
@@ -26,12 +26,11 @@
     "ts-node": "^10.9.2",
     "ts-standard": "^12.0.2",
     "tsx": "^4.7.0",
-    "typescript": "^5.3.3",
-    "vitest": "^1.2.2"
+    "typescript": "^5.3.3"
   },
   "dependencies": {
     "@apollo/server": "^4.10.0",
-    "crypto-random-string": "^3.0.0",
+    "awilix": "^11.0.0",
     "dotenv": "^16.4.1",
     "graphql": "^16.8.1",
     "graphql-scalars": "^1.22.4",

src/app.ts

@@ -3,7 +3,11 @@ import { resolvers } from "./resolvers";
 import { startStandaloneServer } from "@apollo/server/standalone";
 import { readFileSync } from "fs";
 import { typeDefs as scalarTypeDefs } from "graphql-scalars";
-import { migrateAll } from "./services/databaseManagement";
+import { mainDb } from "./db";
+import Knex, { Knex as KnexType } from 'knex'
+import knexfile from "../knexfile";
+import { container } from "./compositionRoot";
+import { asValue } from "awilix";
 
 const typeDefs = readFileSync("src/schema.graphql", { encoding: "utf-8" });
 
@@ -15,17 +19,42 @@ const server = new ApolloServer({
 });
 
 const startServer = async (): Promise<void> => {
+  const plannedMigrations: Array<{ file: string }> = (
+    await mainDb.migrate.list()
+  )[1];
+  if (plannedMigrations.length > 0) {
+    console.log(
+      `🕰️  planning migrations: ${plannedMigrations
+        .map((m) => m.file)
+        .join(",")}`,
+    );
+  }
+  await mainDb.migrate.latest();
+
+  const regions = await mainDb('regions')
+  const regionalDBs = new Map<string, KnexType>(regions.map(region => [region.name, Knex({ ...knexfile, connection: region.connectionString })]))
+  await Promise.all(Array.from(regionalDBs.values()).map(db => db.migrate.latest())).catch(err => console.log({ err }))
+
+  container.register({
+    regionalDBs: asValue(regionalDBs),
+  })
+
   const { url } = await startStandaloneServer(server, {
-    listen: { port: 4000 },
+    listen: { port: 3000 },
+    context: async ({ req }) => {
+      const scope = container.createScope(); // Create a scope per request
+      return {
+        container: scope,
+        // Add any other custom context, like user from req if needed
+      };
+    },
   });
-
-  await migrateAll();
-
   console.log(`🚀 Server ready at: ${url}`);
 };
 
 startServer()
   .then()
-  .catch((err: Error) =>
-    console.log(`🔥 failed to start server ${err.message}`),
-  );
+  .catch((err: Error) => {
+    console.log({ err });
+    console.log(`🔥 failed to start server ${err.message}`);
+  });

src/compositionRoot.ts

@@ -0,0 +1,17 @@
+import { asFunction, asValue, createContainer, InjectionMode } from 'awilix'
+import { mainDb } from './db'
+import { countComments, countResources, queryComments, queryResource, queryResourceAcl, queryUser } from './repositories'
+
+export const container = createContainer({
+  injectionMode: InjectionMode.PROXY,
+  strict: true,
+}).register({
+  mainDB: asValue(mainDb),
+  queryUser: asFunction(queryUser).scoped(),
+  queryResource: asFunction(queryResource).scoped(),
+  queryResourceAcl: asFunction(queryResourceAcl).scoped(),
+  countResources: asFunction(countResources).scoped(),
+  countComments: asFunction(countComments).scoped(),
+  queryComments: asFunction(queryComments).scoped(),
+})
+

src/config.ts

@@ -2,8 +2,8 @@ import 'dotenv/config'
 import { parseEnv } from 'znv'
 import { z } from 'zod'
 
-export const { POSTGRES_URL } = parseEnv(process.env, {
-  POSTGRES_URL: z.string().min(1)
+const config = parseEnv(process.env, {
+  MAIN_DB_URI: z.string().min(1)
 })
 
-console.log([POSTGRES_URL].join(', '))
+export default config

src/db.ts

@@ -1,4 +1,10 @@
 import Knex from 'knex'
-import config from '../knexfile'
+import config from './config'
+import knexfile from '../knexfile'
 
-export const knex = Knex(config)
+const knexConfig = {
+  ...knexfile,
+  connection: config.MAIN_DB_URI,
+}
+
+export const mainDb = Knex(knexConfig)

src/migrations/20240205145527_organizations.ts

@@ -1,14 +0,0 @@
-import type { Knex } from "knex";
-
-const tableName = "organizations";
-
-export async function up(knex: Knex): Promise<void> {
-  return await knex.schema.createTable(tableName, (table) => {
-    table.text("id").primary();
-    table.text("name");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  return await knex.schema.dropTable(tableName);
-}

src/migrations/20240205150932_regions.ts

@@ -1,49 +0,0 @@
-import type { Knex } from "knex";
-
-const regionsTableName = "regions";
-
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.createTable(regionsTableName, (table) => {
-    table.text("id").primary();
-    table.text("connectionString");
-  });
-  await knex.schema.createTable("organizations_regions", (table) => {
-    table
-      .text("organizationId")
-      .references("id")
-      .inTable("organizations")
-      .notNullable()
-      .onDelete("cascade");
-    table
-      .text("regionId")
-      .references("id")
-      .inTable("regions")
-      .notNullable()
-      .onDelete("cascade");
-  });
-  await knex.schema.createTable("resource_organization_region", (table) => {
-    table
-      .text("resourceId")
-      .references("id")
-      .inTable("resources")
-      .notNullable()
-      .onDelete("cascade");
-    table
-      .text("organizationId")
-      .references("id")
-      .inTable("organizations")
-      .notNullable()
-      .onDelete("cascade");
-    table
-      .text("regionId")
-      .references("id")
-      .inTable("regions")
-      .notNullable()
-      .onDelete("cascade");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  await knex.schema.dropTable(regionsTableName);
-  await knex.schema.dropTable("organizations_regions");
-}

src/migrations/20240206210140_region_name.ts

@@ -1,15 +0,0 @@
-import type { Knex } from "knex";
-
-const regionsTableName = "regions";
-
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.alterTable(regionsTableName, (table) => {
-    table.text("name").notNullable().defaultTo("region");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  await knex.schema.alterTable(regionsTableName, (table) => {
-    table.dropColumn("name");
-  });
-}

src/migrations/20240206213031_region_maintenance_db.ts

@@ -1,15 +0,0 @@
-import type { Knex } from "knex";
-
-const regionsTableName = "regions";
-
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.alterTable(regionsTableName, (table) => {
-    table.text("maintenanceDb").notNullable().defaultTo("region");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  await knex.schema.alterTable(regionsTableName, (table) => {
-    table.dropColumn("maintenanceDb");
-  });
-}

src/migrations/20240207203256_organization_acl.ts

@@ -1,22 +0,0 @@
-import type { Knex } from "knex";
-
-const tableName = "organization_acl";
-
-export async function up(knex: Knex): Promise<void> {
-  return await knex.schema.createTable(tableName, (table) => {
-    table
-      .string("userId")
-      .references("id")
-      .inTable("users")
-      .onDelete("cascade");
-    table
-      .string("organizationId")
-      .references("id")
-      .inTable("organizations")
-      .onDelete("cascade");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  return await knex.schema.dropTable(tableName);
-}

src/migrations/20240207212311_organization_resource_acl.ts

@@ -1,22 +0,0 @@
-import type { Knex } from "knex";
-
-const tableName = "organization_resource_acl";
-
-export async function up(knex: Knex): Promise<void> {
-  return await knex.schema.createTable(tableName, (table) => {
-    table
-      .string("resourceId")
-      .references("id")
-      .inTable("resources")
-      .onDelete("cascade");
-    table
-      .string("organizationId")
-      .references("id")
-      .inTable("organizations")
-      .onDelete("cascade");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  return await knex.schema.dropTable(tableName);
-}

src/migrations/20240207214054_resource_region.ts

@@ -1,28 +0,0 @@
-import type { Knex } from "knex";
-
-const tableName = "resource_region_organization";
-
-export async function up(knex: Knex): Promise<void> {
-  return await knex.schema.createTable(tableName, (table) => {
-    table
-      .string("resourceId")
-      .references("id")
-      .inTable("resources")
-      .onDelete("cascade")
-      .primary();
-    table
-      .string("regionId")
-      .references("id")
-      .inTable("regions")
-      .onDelete("cascade");
-    table
-      .string("organizationId")
-      .references("id")
-      .inTable("organizations")
-      .onDelete("cascade");
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  return await knex.schema.dropTable(tableName);
-}

src/migrations/20240909084104_create_regions_table.ts

@@ -0,0 +1,16 @@
+import type { Knex } from "knex";
+
+
+export async function up(knex: Knex): Promise<void> {
+  return await knex.schema.createTable('regions', (table) => {
+    table.text('id').primary()
+    table.text('name')
+    table.text('connectionString')
+  })
+}
+
+
+export async function down(knex: Knex): Promise<void> {
+  return await knex.schema.dropTable('regions')
+}
+

src/migrations/20240909142409_add_region_to_resources.ts

@@ -0,0 +1,16 @@
+import type { Knex } from "knex";
+
+
+export async function up(knex: Knex): Promise<void> {
+  return await knex.schema.createTable('resource_meta', (table) => {
+    table.text('id').primary()
+    table.text('resourceId').references('id').inTable('resources')
+    table.text('region')
+  })
+}
+
+
+export async function down(knex: Knex): Promise<void> {
+  return await knex.schema.dropTable('resource_meta')
+}
+

src/repositories.ts

@@ -1,74 +1,47 @@
 import { Knex } from "knex";
-import { knex } from "./db";
-import {
-  UserRecord,
-  Resource,
-  ResourceAcl,
-  Comment,
-  Region,
-  OrganizationsRegions,
-  Organization,
-  OrganizationAcl,
-  OrganizationResourceAcl,
-  ResourceRegion,
-  ResourceRegionOrg,
-} from "./types";
+import { UserRecord, Resource, ResourceAcl, Comment, ResourceMeta } from "./types";
 
-const Users = () => knex<UserRecord>("users");
-const Resources = () => knex<Resource>("resources");
-const ResourceAclRepo = () => knex<ResourceAcl>("resource_acl");
+const tables = {
+  users: (db: Knex) => db<UserRecord>('users'),
+  resources: (db: Knex) => db<Resource>('resources'),
+  resourceAcl: (db: Knex) => db<ResourceAcl>('resource_acl'),
+  comments: (db: Knex) => db<Comment>('comments'),
+  resourceMeta: (db: Knex) => db<ResourceMeta>('resource_meta'),
+}
 
-export const queryUser = async (userId: string): Promise<UserRecord | null> => {
-  return (await Users().where("id", "=", userId).first()) ?? null;
+export const queryUser = ({ mainDB }: { mainDB: Knex }) => async (userId: string): Promise<UserRecord | null> => {
+  return (await tables.users(mainDB).where("id", "=", userId).first()) ?? null;
 };
 
-export const getUsersFrom = (db: Knex) => async (): Promise<UserRecord[]> => {
-  return await db<UserRecord>("users").select();
+export const queryResource = ({ mainDB, regionalDBs }: { mainDB: Knex, regionalDBs: Map<string, Knex> }) => async (
+  resourceId: string,
+): Promise<Resource | null> => {
+  const resourceMeta = await tables.resourceMeta(mainDB).where({ resourceId }).first()
+  const regionalDB = regionalDBs.get(resourceMeta!.region)!
+  return (await tables.resources(regionalDB).where("id", "=", resourceId).first()) ?? null;
 };
 
-export const saveUserTo =
-  (db: Knex) =>
-  async (user: UserRecord): Promise<void> => {
-    await db<UserRecord>("users").insert(user);
-  };
+export const queryResourceAcl = ({ mainDB }: { mainDB: Knex }) => async ({
+  resourceId,
+  userId,
+}: {
+  resourceId: string;
+  userId: string;
+}): Promise<ResourceAcl | null> => {
+  return (
+    (await tables.resourceAcl(mainDB)
+      .where("userId", "=", userId)
+      .andWhere("resourceId", "=", resourceId)
+      .first()) ?? null
+  );
+};
 
-export const saveResourceTo =
-  (db: Knex) =>
-  async (resource: Resource): Promise<void> => {
-    await db<Resource>("resources").insert(resource);
-  };
-
-export const queryResourceFrom =
-  (db: Knex) =>
-  async (resourceId: string): Promise<Resource | null> => {
-    return (
-      (await db<Resource>("resources").where({ id: resourceId }).first()) ??
-      null
-    );
-  };
-
-export const queryResourceAclFrom =
-  (db: Knex) =>
-  async ({ resourceId, userId }: ResourceAcl): Promise<ResourceAcl | null> => {
-    return (
-      (await db<ResourceAcl>("resource_acl")
-        .where({ userId, resourceId })
-        .first()) ?? null
-    );
-  };
-
-export const saveResourceAclTo =
-  (db: Knex) =>
-  async (resourceAcl: ResourceAcl): Promise<void> => {
-    await db<ResourceAcl>("resource_acl").insert(resourceAcl);
-  };
-
-export const countResources = async (userId: string): Promise<number> => {
-  const [rawCount] = await ResourceAclRepo().count().where({ userId });
+export const countResources = ({ mainDB }: { mainDB: Knex }) => async (userId: string): Promise<number> => {
+  const [rawCount] = await tables.resourceAcl(mainDB).count().where({ userId });
   return parseInt(rawCount.count as string);
 };
 
-export const queryResources = async ({
+export const queryResources = ({ mainDB, regionalDBs }: { mainDB: Knex; regionalDBs: Record<string, Knex> }) => async ({
   userId,
   limit,
   cursor,
@@ -77,6 +50,8 @@ export const queryResources = async ({
   limit: number;
   cursor: string | null;
 }) => {
+  const resourceMeta = await tables.resourceMeta(mainDB).where({ resourceId }).first()
+  const regionalDB = regionalDBs[resourceMeta!.region]
   const query = Resources()
     .join("resource_acl", "resources.id", "resource_acl.resourceId")
     .where({ userId });
@@ -86,115 +61,23 @@ export const queryResources = async ({
   return await query.limit(limit);
 };
 
-export const countCommentsIn =
-  (db: Knex) =>
-  async (resourceId: string): Promise<number> => {
-    const [rawCount] = await db<Comment>("comments")
-      .count()
-      .where({ resourceId });
-    return parseInt(rawCount.count as string);
-  };
+export const countComments = ({ mainDB }: { mainDB: Knex }) => async (resourceId: string): Promise<number> => {
+  const [rawCount] = await tables.comments(mainDB).count().where({ resourceId });
+  return parseInt(rawCount.count as string);
+};
 
-export const queryCommentsFrom =
-  (db: Knex) =>
-  async ({
-    resourceId,
-    limit,
-    cursor,
-  }: {
-    resourceId: string;
-    limit: number;
-    cursor: string | null;
-  }): Promise<Comment[]> => {
-    const query = db<Comment>("comments").where({ resourceId });
-    if (cursor) {
-      query.andWhere("createdAt", "<", cursor);
-    }
-    return await query.limit(limit);
-  };
-
-export const saveCommentTo =
-  (db: Knex) =>
-  async (comment: Comment): Promise<void> => {
-    await db<Comment>("comments").insert(comment);
-  };
-
-export const getRegionsFrom = (db: Knex) => async (): Promise<Array<Region>> =>
-  await db<Region>("regions").select();
-
-export const getRegionFrom =
-  (db: Knex) =>
-  async (id: string): Promise<Region | null> =>
-    (await db<Region>("regions").where({ id }).first()) ?? null;
-
-export const getOrganizationRegionsFrom =
-  (db: Knex) => async (): Promise<Array<OrganizationsRegions>> =>
-    await db<OrganizationsRegions>("organizations_regions").select();
-
-export const queryOrganizationRegionsFrom =
-  (db: Knex) =>
-  async ({
-    regionId,
-    organizationId,
-  }: OrganizationsRegions): Promise<OrganizationsRegions | null> =>
-    (await db<OrganizationsRegions>("organizations_regions")
-      .where({ regionId, organizationId })
-      .first()) ?? null;
-
-export const saveRegionTo = (db: Knex) => async (region: Region) =>
-  await db<Region>("regions").insert(region);
-
-export const saveOrganizationTo =
-  (db: Knex) => async (organization: Organization) =>
-    await db<Organization>("organizations").insert(organization);
-
-export const getOrganizationFrom =
-  (db: Knex) =>
-  async (id: string): Promise<Organization | null> => {
-    return (
-      (await db<Organization>("organizations").where({ id }).first()) ?? null
-    );
-  };
-
-export const getOrganizationsFrom =
-  (db: Knex) => async (): Promise<Organization[]> =>
-    await db<Organization>("organizations").select();
-
-export const saveOrganizationsRegionsTo =
-  (db: Knex) =>
-  async (or: OrganizationsRegions): Promise<void> =>
-    await db<OrganizationsRegions>("organizations_regions").insert(or);
-
-export const saveOrganizationAclTo =
-  (db: Knex) =>
-  async (orgAcl: OrganizationAcl): Promise<void> => {
-    await db<OrganizationsRegions>("organization_acl").insert(orgAcl);
-  };
-
-export const queryOrganizationAclFrom =
-  (db: Knex) =>
-  async ({
-    userId,
-    organizationId,
-  }: OrganizationAcl): Promise<OrganizationAcl | null> =>
-    (await db<OrganizationAcl>("organization_acl")
-      .where({ userId, organizationId })
-      .first()) ?? null;
-
-export const saveOrganizationResourceAclTo =
-  (db: Knex) =>
-  async (item: OrganizationResourceAcl): Promise<void> => {
-    await db<OrganizationResourceAcl>("organization_resource_acl").insert(item);
-  };
-
-export const saveResourceRegionOrganizationTo =
-  (db: Knex) => async (item: ResourceRegionOrg) => {
-    await db<ResourceRegionOrg>("resource_region_organization").insert(item);
-  };
-
-export const queryResourceRegionOrganizationFrom =
-  (db: Knex) =>
-  async (resourceId: string): Promise<ResourceRegion | null> =>
-    (await db<ResourceRegionOrg>("resource_region_organization")
-      .where({ resourceId })
-      .first()) ?? null;
+export const queryComments = ({ mainDB }: { mainDB: Knex }) => async ({
+  resourceId,
+  limit,
+  cursor,
+}: {
+  resourceId: string;
+  limit: number;
+  cursor: string | null;
+}): Promise<Comment[]> => {
+  const query = tables.comments(mainDB).where({ resourceId });
+  if (cursor) {
+    query.andWhere("createdAt", "<", cursor);
+  }
+  return await query.limit(limit);
+};

src/resolvers.ts

@@ -1,63 +1,27 @@
-import {
-  getOrganizationsFrom,
-  getRegionsFrom,
-  queryOrganizationAclFrom,
-  queryOrganizationRegionsFrom,
-  queryResourceAclFrom,
-  saveOrganizationResourceAclTo,
-  saveOrganizationAclTo,
-  saveResourceAclTo,
-  saveResourceTo,
-  saveResourceRegionOrganizationTo,
-  saveCommentTo,
-  queryResourceFrom,
-  queryUser,
-  countCommentsIn,
-  queryCommentsFrom,
-  getUsersFrom,
-  saveUserTo,
-} from "./repositories";
-import { getComments } from "./services/comments";
-import { createResource, getResources } from "./services/resources";
+import { queryResource, queryResourceAcl } from "./repositories";
+import { getUser, getResource, getComments, getResources } from "./services";
 import { GraphQLError } from "graphql";
 import {
   Resource,
+  ResourceCollection,
   UserRecord,
   CommentCollection,
   PaginationArgs,
-  ResourceCreateArgs,
-  OrganizationsRegions,
-  OrganizationAcl,
-  CommentCreateArgs,
-  UserCreateArgs,
 } from "./types";
-import {
-  bindRegionToOrganization,
-  createOrganization,
-  getDbClient,
-  getMainDbClient,
-  getResourceDatabaseConnection,
-  registerRegion,
-} from "./services/databaseManagement";
-import { authorizeUserOrgRegion } from "./services/authz";
-import cryptoRandomString from "crypto-random-string";
 
 // Resolvers define how to fetch the types defined in your schema.
 // This resolver retrieves books from the "books" array above.
 export const resolvers = {
   Query: {
-    async users() {
-      return await getUsersFrom(getMainDbClient())();
-    },
-    async user(_: unknown, args: { id: string }) {
-      return await queryUser(args.id);
+    async user(_: unknown, args: { id: string }, ctx) {
+      return await ctx.container.cradle.queryUser(args.id);
     },
     async resource(
       _: unknown,
       args: { id: string; userId: string },
+      ctx
     ): Promise<Resource> {
-      const mainDb = getMainDbClient();
-      const maybeAcl = await queryResourceAclFrom(mainDb)({
+      const maybeAcl = await ctx.container.cradle.queryResourceAcl({
         userId: args.userId,
         resourceId: args.id,
       });
@@ -71,8 +35,7 @@ export const resolvers = {
           },
         );
       }
-      const db = await getResourceDatabaseConnection(args.id);
-      const maybeResource = await queryResourceFrom(db)(args.id);
+      const maybeResource = await ctx.container.cradle.queryResource(args.id);
       if (maybeResource == null) {
         throw new GraphQLError("Resource not found", {
           extensions: { code: "RESOURCE_NOT_FOUND" },
@@ -80,12 +43,6 @@ export const resolvers = {
       }
       return maybeResource;
     },
-    async organizations() {
-      return await getOrganizationsFrom(getMainDbClient())();
-    },
-    async regions() {
-      return await getRegionsFrom(getMainDbClient())();
-    },
   },
   User: {
     async resources(parent: UserRecord, args: PaginationArgs) {
@@ -97,100 +54,11 @@ export const resolvers = {
       parent: Resource,
       { limit, cursor }: PaginationArgs,
     ): Promise<CommentCollection> {
-      const db = await getResourceDatabaseConnection(parent.id);
-      return await getComments(
-        countCommentsIn(db),
-        queryCommentsFrom(db),
-      )({
+      return await getComments({
         resourceId: parent.id,
         limit,
         cursor,
       });
     },
   },
-  Mutation: {
-    async createUser(
-      _: unknown,
-      { input: { name } }: { input: UserCreateArgs },
-    ) {
-      const id = cryptoRandomString({ length: 10 });
-      await saveUserTo(getMainDbClient())({ id, name });
-      return id;
-    },
-    async registerRegion(
-      _: unknown,
-      args: {
-        name: string;
-        connectionString: string;
-        maintenanceDb: string;
-      },
-    ) {
-      return await registerRegion(args);
-    },
-    async createOrganization(_: unknown, args: { name: string }) {
-      return await createOrganization(args.name);
-    },
-    async addRegionToOrganization(_: unknown, args: OrganizationsRegions) {
-      await bindRegionToOrganization(args);
-    },
-    async addUserToOrganization(
-      _: unknown,
-      { input: args }: { input: OrganizationAcl },
-    ) {
-      await saveOrganizationAclTo(getMainDbClient())(args);
-    },
-    async createResource(
-      _: unknown,
-      { input: args }: { input: ResourceCreateArgs },
-    ) {
-      const mainDb = getMainDbClient();
-      await authorizeUserOrgRegion(
-        queryOrganizationAclFrom(mainDb),
-        queryOrganizationRegionsFrom(mainDb),
-      )(args);
-
-      const db =
-        args.regionId && args.organizationId
-          ? await getDbClient({
-              regionId: args.regionId,
-              organizationId: args.organizationId,
-            })
-          : mainDb;
-
-      const resourceId = await createResource(
-        saveResourceTo(db),
-        saveResourceAclTo(mainDb),
-      )(args);
-
-      if (args.organizationId) {
-        await saveOrganizationResourceAclTo(mainDb)({
-          organizationId: args.organizationId,
-          resourceId,
-        });
-        await saveResourceRegionOrganizationTo(mainDb)({
-          resourceId,
-          organizationId: args.organizationId,
-          // i know its not null here, the authz function ensures it
-          regionId: args.regionId!,
-        });
-      }
-      return resourceId;
-    },
-    async addComment(
-      _: unknown,
-      { input: args }: { input: CommentCreateArgs },
-    ) {
-      const mainDb = getMainDbClient();
-      const resourceAcl = await queryResourceAclFrom(mainDb)(args);
-      if (!resourceAcl)
-        throw new Error("The user doesn't have access to the given resource");
-      //2. get resource db client
-      const db = await getResourceDatabaseConnection(args.resourceId);
-      //3. save comment to db
-      const id = cryptoRandomString({ length: 10 });
-      const createdAt = new Date();
-      await saveCommentTo(db)({ id, createdAt, ...args });
-      return id;
-    },
-  },
 };

src/schema.graphql

@@ -30,59 +30,8 @@ type User {
   resources(limit: Int! = 10, cursor: String = null): ResourceCollection!
 }
 
-type Organization {
-  id: String!
-  name: String!
-}
-
-type Region {
-  id: String!
-  name: String!
-  maintenanceDb: String!
-}
-
 type Query {
   user(id: String!): User
-  users: [User!]
 
   resource(id: String!, userId: String!): Resource
-
-  organizations: [Organization!]
-  regions: [Region!]
-}
-
-input ResourceCreateInput {
-  userId: String!
-  name: String!
-  organizationId: String = null
-  regionId: String = null
-}
-
-input OrganizationAcl {
-  userId: String!
-  organizationId: String!
-}
-
-input CommentInput {
-  userId: String!
-  content: String!
-  resourceId: String!
-}
-
-input UserCreateArgs {
-  name: String!
-}
-
-type Mutation {
-  createUser(input: UserCreateArgs!): String!
-  registerRegion(
-    name: String!
-    connectionString: String!
-    maintenanceDb: String!
-  ): String!
-  createOrganization(name: String!): String!
-  addRegionToOrganization(organizationId: String!, regionId: String!): Boolean
-  addUserToOrganization(input: OrganizationAcl!): Boolean
-  createResource(input: ResourceCreateInput!): String!
-  addComment(input: CommentInput!): String!
 }

src/services.ts

@@ -0,0 +1,61 @@
+import {
+  queryUser,
+  queryResource,
+  countComments,
+  queryComments,
+  countResources,
+  queryResources,
+} from "./repositories";
+import {
+  UserRecord,
+  Resource,
+  CommentCollection,
+  PaginationArgs,
+  ResourceCollection,
+} from "./types";
+
+export const getUser = async (id: string): Promise<UserRecord | null> => {
+  return await queryUser(id);
+};
+
+export const getResource = async (id: string): Promise<Resource | null> => {
+  return await queryResource(id);
+};
+
+interface GetResourcesArgs extends PaginationArgs {
+  userId: string;
+}
+export const getResources = async (
+  params: GetResourcesArgs,
+): Promise<ResourceCollection> => {
+  const totalCount = await countResources(params.userId);
+  const items = await queryResources(params);
+  let cursor = null;
+  if (items.length > 0) {
+    cursor = items.slice(-1)[0].createdAt.toISOString();
+  }
+  return {
+    totalCount,
+    items,
+    cursor,
+  };
+};
+
+export const getComments = async (params: {
+  resourceId: string;
+  limit: number;
+  cursor: string | null;
+}): Promise<CommentCollection> => {
+  // yes, i should be doing base64 de and encoding with the cursor...
+  const totalCount = await countComments(params.resourceId);
+  const items = await queryComments(params);
+  let cursor = null;
+  if (items.length > 0) {
+    cursor = items.slice(-1)[0].createdAt.toISOString();
+  }
+  return {
+    totalCount,
+    items,
+    cursor,
+  };
+};

src/services/authz.ts

@@ -1,26 +0,0 @@
-import {
-  OrganizationAcl,
-  OrganizationsRegions,
-  UserOrgRegionArgs,
-} from "../types";
-
-export const authorizeUserOrgRegion =
-  (
-    orgAclGetter: (params: OrganizationAcl) => Promise<OrganizationAcl | null>,
-    orgRegionGetter: (
-      params: OrganizationsRegions,
-    ) => Promise<OrganizationsRegions | null>,
-  ) =>
-  async ({ userId, regionId, organizationId }: UserOrgRegionArgs) => {
-    if (!organizationId && regionId)
-      throw new Error("public org doesn't support regions");
-    if (organizationId) {
-      if (!regionId) throw new Error("organizations can only write to regions");
-      const orgAcl = await orgAclGetter({ organizationId, userId });
-      if (!orgAcl)
-        throw new Error("user doesn't have access to this organization");
-      const orgRegion = await orgRegionGetter({ organizationId, regionId });
-      if (!orgRegion)
-        throw new Error("organization doesnt have access to this region");
-    }
-  };

src/services/comments.ts

@@ -1,25 +0,0 @@
-import { CommentCollection, PaginationArgs, Comment } from "../types";
-
-interface GetCommentsArgs extends PaginationArgs {
-  resourceId: string;
-}
-
-export const getComments =
-  (
-    countComments: (resourceId: string) => Promise<number>,
-    queryComments: (params: GetCommentsArgs) => Promise<Comment[]>,
-  ) =>
-  async (params: GetCommentsArgs): Promise<CommentCollection> => {
-    // yes, i should be doing base64 de and encoding with the cursor...
-    const totalCount = await countComments(params.resourceId);
-    const items = await queryComments(params);
-    let cursor = null;
-    if (items.length > 0) {
-      cursor = items.slice(-1)[0].createdAt.toISOString();
-    }
-    return {
-      totalCount,
-      items,
-      cursor,
-    };
-  };

src/services/databaseManagement.ts

@@ -1,243 +0,0 @@
-import { POSTGRES_URL } from "../config";
-import {
-  getOrganizationFrom,
-  getOrganizationRegionsFrom,
-  getRegionFrom,
-  queryResourceRegionOrganizationFrom,
-  saveOrganizationTo,
-  saveOrganizationsRegionsTo,
-  saveRegionTo,
-} from "../repositories";
-import { OrganizationsRegions, Region } from "../types";
-import knex, { Knex } from "knex";
-import cryptoRandomString from "crypto-random-string";
-
-const migrateToLatest = async (client: Knex): Promise<void> => {
-  const plannedMigrations: Array<{ file: string }> = (
-    await client.migrate.list()
-  )[1];
-  if (plannedMigrations.length > 0) {
-    console.log(
-      `🕰️  planning migrations: ${plannedMigrations
-        .map((m) => m.file)
-        .join(",")}`,
-    );
-  } else {
-    console.log("no migrations are planned");
-  }
-  // TODO: make sure if a migration fails, all migrations are rolled back
-  await client.migrate.latest();
-};
-
-export const migrateAll = async (): Promise<void> => {
-  await migrateToLatest(mainClient);
-  const databaseSchemas = await getAllDatabaseSchemaConnections();
-
-  await Promise.all([
-    ...databaseSchemas.map(async (sc) => await migrateToLatest(sc)),
-  ]);
-  // 1. get all regions from main DB
-  // 2. construct region specific knex clients and cache them by
-  // 3. structure the cache so that it accomodates client creation by resource id
-  // 4. get all organization regions from main DB
-  // 5. for in all regions for all organizations, run the migration
-  // 6. do not forget the migration for the main DB
-  //
-};
-
-const createDatabaseConfig = (connectionString: string): Knex.Config => {
-  return {
-    client: "pg",
-    connection: {
-      connectionString,
-    },
-    // connection: connectionString,
-    migrations: {
-      directory: "src/migrations",
-      extension: "ts",
-    },
-  };
-};
-
-const mainClient = knex(createDatabaseConfig(POSTGRES_URL));
-
-const _connectionStore: Map<string, Knex> = new Map();
-
-interface RegionWithMaybeOrganization {
-  regionId: string;
-  organizationId?: string | undefined;
-}
-
-const _createConnectionKey = ({
-  organizationId,
-  regionId,
-}: RegionWithMaybeOrganization): string => {
-  return organizationId ? `${organizationId}@${regionId}` : regionId;
-};
-
-export const getDbClient = async ({
-  regionId,
-  organizationId,
-}: RegionWithMaybeOrganization): Promise<Knex> => {
-  const connectionKey = _createConnectionKey({ organizationId, regionId });
-  const maybeClient = _connectionStore.get(connectionKey);
-  if (maybeClient) return maybeClient;
-  const maybeRegion = await mainClient<Region>("regions")
-    .select()
-    .where({ id: regionId })
-    .first();
-  if (!maybeRegion) throw Error(`region ${regionId} not found`);
-  const connectionString = organizationId
-    ? `${maybeRegion.connectionString}/${organizationId}`
-    : `${maybeRegion.connectionString}/${maybeRegion.maintenanceDb}`;
-  const client = knex(createDatabaseConfig(connectionString));
-  _connectionStore.set(connectionKey, client);
-  return client;
-};
-
-export const getMainDbClient = (): Knex => mainClient;
-
-export const registerRegion = async ({
-  name,
-  connectionString,
-  maintenanceDb,
-}: {
-  name: string;
-  connectionString: string;
-  maintenanceDb: string;
-}): Promise<string> => {
-  // TODO: validate the connectionString, so that the knex client can connect to it
-  const id = cryptoRandomString({ length: 10 });
-  await saveRegionTo(mainClient)({
-    id,
-    name,
-    connectionString,
-    maintenanceDb,
-  });
-  return id;
-};
-
-export const createOrganization = async (name: string): Promise<string> => {
-  const id = cryptoRandomString({ length: 10 });
-  await saveOrganizationTo(mainClient)({ id, name });
-  return id;
-};
-
-const createDb = async (client: Knex, name: string): Promise<void> => {
-  try {
-    await client.raw(`create database "${name}"`);
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    if (!err.message.includes("already exists")) throw err;
-  }
-};
-
-const setUpUserReplication = async ({
-  from,
-  to,
-}: {
-  from: Knex;
-  to: Knex;
-}): Promise<void> => {
-  // TODO: ensure its created...
-  const connectionString: string =
-    from.client.config.connection.connectionString;
-  try {
-    await from.raw("CREATE PUBLICATION userspub FOR TABLE users;");
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    if (!err.message.includes("already exists")) throw err;
-  }
-  try {
-    const toUrl = new URL(to.client.config.connection.connectionString);
-    await to.raw(
-      `CREATE SUBSCRIPTION userssub_${toUrl.pathname.replace("/", "")} CONNECTION '${connectionString}' PUBLICATION userspub;`,
-    );
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    if (!err.message.includes("already exists")) throw err;
-  }
-};
-
-const setUpResourceReplication = async ({
-  from,
-  fromRegionName,
-  to,
-}: {
-  from: Knex;
-  fromRegionName: string;
-  to: Knex;
-}): Promise<void> => {
-  // TODO: ensure its created...
-  const connectionString: string =
-    from.client.config.connection.connectionString;
-  const connUrl = new URL(connectionString);
-  try {
-    await from.raw("CREATE PUBLICATION resourcepub FOR TABLE resources;");
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    if (!err.message.includes("already exists")) throw err;
-  }
-  try {
-    await to.raw(
-      `CREATE SUBSCRIPTION "resroucesub_${fromRegionName.replace(
-        " ",
-        "",
-      )}_${connUrl.pathname.replace(
-        "/",
-        "",
-      )}" CONNECTION '${connectionString}' PUBLICATION resourcepub;`,
-    );
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    if (!err.message.includes("already exists")) throw err;
-  }
-};
-
-export const bindRegionToOrganization = async ({
-  regionId,
-  organizationId,
-}: OrganizationsRegions): Promise<void> => {
-  const region = await getRegionFrom(mainClient)(regionId);
-  if (!region) throw Error(`region ${regionId} not found`);
-  const organization = await getOrganizationFrom(mainClient)(organizationId);
-  if (!organization) throw Error(`organization ${organizationId} not found`);
-
-  const regionClient = await getDbClient({ regionId });
-
-  await createDb(regionClient, organizationId);
-
-  const client = await getDbClient({ organizationId, regionId });
-  const connectionKey = _createConnectionKey({ organizationId, regionId });
-
-  await migrateToLatest(client);
-
-  await setUpUserReplication({ from: mainClient, to: client });
-  await setUpResourceReplication({
-    from: client,
-    fromRegionName: region.name,
-    to: mainClient,
-  });
-
-  _connectionStore.set(connectionKey, client);
-  await saveOrganizationsRegionsTo(mainClient)({ organizationId, regionId });
-};
-
-export const getAllDatabaseSchemaConnections = async (): Promise<Knex[]> => {
-  const organizationRegions = await getOrganizationRegionsFrom(mainClient)();
-  const clients = await Promise.all(
-    organizationRegions.map(async (or) => {
-      const client = await getDbClient(or);
-      return client;
-    }),
-  );
-  return [mainClient, ...clients];
-};
-
-export const getResourceDatabaseConnection = async (
-  resourceId: string,
-): Promise<Knex> => {
-  const resourceRegionOrg =
-    await queryResourceRegionOrganizationFrom(mainClient)(resourceId);
-  return resourceRegionOrg ? await getDbClient(resourceRegionOrg) : mainClient;
-};

src/services/resources.ts

@@ -1,45 +0,0 @@
-import cryptoRandomString from "crypto-random-string";
-import { countResources, queryResources } from "../repositories";
-import {
-  Resource,
-  PaginationArgs,
-  ResourceCollection,
-  ResourceCreateArgs,
-  ResourceAcl,
-} from "../types";
-
-interface GetResourcesArgs extends PaginationArgs {
-  userId: string;
-}
-export const getResources = async (
-  params: GetResourcesArgs,
-): Promise<ResourceCollection> => {
-  const totalCount = await countResources(params.userId);
-  const items = await queryResources(params);
-  let cursor = null;
-  if (items.length > 0) {
-    cursor = items.slice(-1)[0].createdAt.toISOString();
-  }
-  return {
-    totalCount,
-    items,
-    cursor,
-  };
-};
-
-export const createResource =
-  (
-    resourceSaver: (resource: Resource) => Promise<void>,
-    resourceAclSaver: (resourceAcl: ResourceAcl) => Promise<void>,
-  ) =>
-  async ({ userId, name }: ResourceCreateArgs): Promise<string> => {
-    //1. if no org, create project in main region, validate that, regionId is null
-    //2. if org, validate if user has access to the org
-    //3. if org and region, validate if org has access to region
-    //4. create resource
-    const id = cryptoRandomString({ length: 10 });
-    const resource = { id, name, createdAt: new Date() };
-    await resourceSaver(resource);
-    await resourceAclSaver({ resourceId: id, userId });
-    return id;
-  };

src/types.ts

@@ -1,12 +1,9 @@
-export interface CommentCreateArgs {
+export interface Comment {
+  id: string;
   userId: string;
   content: string;
-  resourceId: string;
-}
-
-export interface Comment extends CommentCreateArgs {
-  id: string;
   createdAt: Date;
+  resourceId: string;
 }
 
 export interface PaginationArgs {
@@ -20,32 +17,20 @@ interface Collection<T> {
   items: T[];
 }
 
-export interface CommentCollection extends Collection<Comment> {}
-
-export interface UserOrgRegionArgs {
-  userId: string;
-  organizationId: string | null;
-  regionId: string | null;
-}
-
-export interface ResourceCreateArgs extends UserOrgRegionArgs {
-  name: string;
-}
+export interface CommentCollection extends Collection<Comment> { }
 
 export interface Resource {
   id: string;
   name: string;
   createdAt: Date;
+  region: string
 }
 
-export interface ResourceCollection extends Collection<Resource> {}
+export interface ResourceCollection extends Collection<Resource> { }
 
-export interface UserCreateArgs {
-  name: string;
-}
-
-export interface UserRecord extends UserCreateArgs {
+export interface UserRecord {
   id: string;
+  name: string;
 }
 
 export interface User extends UserRecord {
@@ -61,38 +46,8 @@ export interface ResourceAcl {
   resourceId: string;
 }
 
-export interface Region {
-  id: string;
-  name: string;
-  connectionString: string;
-  maintenanceDb: string;
-}
-
-export interface Organization {
-  id: string;
-  name: string;
-}
-
-export interface OrganizationAcl {
-  userId: string;
-  organizationId: string;
-}
-
-export interface OrganizationsRegions {
-  organizationId: string;
-  regionId: string;
-}
-
-export interface OrganizationResourceAcl {
-  organizationId: string;
+export interface ResourceMeta {
+  id: string
+  region: string;
   resourceId: string;
 }
-
-export interface ResourceRegion {
-  resourceId: string;
-  regionId: string;
-}
-
-export interface ResourceRegionOrg extends ResourceRegion {
-  organizationId: string;
-}

tests/integration/regions.spec.ts

@@ -1,29 +0,0 @@
-import { expect, beforeAll, describe, it } from "vitest";
-import {
-  getOrganizationRegionsFrom,
-  getRegionsFrom,
-} from "../../src/repositories";
-import {
-  getMainDbClient,
-  migrateAll,
-} from "../../src/services/databaseManagement";
-import { Knex } from "knex";
-
-describe("regions", () => {
-  let dbClient: Knex;
-
-  beforeAll(async () => {
-    dbClient = await getMainDbClient();
-  });
-  it("gets all regions", async () => {
-    const regions = await getRegionsFrom(dbClient)();
-    expect(regions.length).toBeGreaterThan(0);
-  });
-  it("gets organizations regions", async () => {
-    const orgRegions = await getOrganizationRegionsFrom(dbClient)();
-    expect(orgRegions.length).toBeGreaterThan(0);
-  });
-  it("migrates all", async () => {
-    await migrateAll();
-  });
-});

tsconfig.json

@@ -11,7 +11,7 @@
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
@@ -25,7 +25,7 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "commonjs" /* Specify what module code is generated. */,
+    "module": "commonjs",                                /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
@@ -77,12 +77,12 @@
     // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
     // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
     // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
 
     /* Type Checking */
-    "strict": true /* Enable all strict type-checking options. */,
+    "strict": true,                                      /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
@@ -104,6 +104,6 @@
 
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true /* Skip type checking all .d.ts files. */,
-  },
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
 }

vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    dir: "tests",
-  },
-});