wip: multi org multi region

src/app.ts

@@ -1,42 +1,31 @@
-import { ApolloServer } from '@apollo/server'
-import { resolvers } from './resolvers'
-import { startStandaloneServer } from '@apollo/server/standalone'
-import { readFileSync } from 'fs'
-import { typeDefs as scalarTypeDefs } from 'graphql-scalars'
-import { knex } from './db'
+import { ApolloServer } from "@apollo/server";
+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";
 
-const typeDefs = readFileSync('src/schema.graphql', { encoding: 'utf-8' })
+const typeDefs = readFileSync("src/schema.graphql", { encoding: "utf-8" });
 
 // The ApolloServer constructor requires two parameters: your schema
 // definition and your set of resolvers.
 const server = new ApolloServer({
   typeDefs: [typeDefs, ...scalarTypeDefs],
-  resolvers
-})
+  resolvers,
+});
 
 const startServer = async (): Promise<void> => {
   const { url } = await startStandaloneServer(server, {
-    listen: { port: 4000 }
-  })
+    listen: { port: 4000 },
+  });
 
-  const plannedMigrations: Array<{ file: string }> = (
-    await knex.migrate.list()
-  )[1]
-  if (plannedMigrations.length > 0) {
-    console.log(
-      `🕰️  planning migrations: ${plannedMigrations
-        .map((m) => m.file)
-        .join(',')}`
-    )
-  }
+  await migrateAll();
 
-  await knex.migrate.latest()
-
-  console.log(`🚀 Server ready at: ${url}`)
-}
+  console.log(`🚀 Server ready at: ${url}`);
+};
 
 startServer()
   .then()
   .catch((err: Error) =>
-    console.log(`🔥 failed to start server ${err.message}`)
-  )
+    console.log(`🔥 failed to start server ${err.message}`),
+  );

src/migrations/20240205145527_organizations.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,28 @@
+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/repositories.ts

@@ -1,35 +1,67 @@
+import { Knex } from "knex";
 import { knex } from "./db";
-import { UserRecord, Resource, ResourceAcl, Comment } from "./types";
+import {
+  UserRecord,
+  Resource,
+  ResourceAcl,
+  Comment,
+  Region,
+  OrganizationsRegions,
+  Organization,
+  OrganizationAcl,
+  OrganizationResourceAcl,
+  ResourceRegion,
+  ResourceRegionOrg,
+} from "./types";
 
 const Users = () => knex<UserRecord>("users");
 const Resources = () => knex<Resource>("resources");
 const ResourceAclRepo = () => knex<ResourceAcl>("resource_acl");
-const Comments = () => knex<Comment>("comments");
 
 export const queryUser = async (userId: string): Promise<UserRecord | null> => {
   return (await Users().where("id", "=", userId).first()) ?? null;
 };
 
-export const queryResource = async (
-  resourceId: string,
-): Promise<Resource | null> => {
-  return (await Resources().where("id", "=", resourceId).first()) ?? null;
+export const getUsersFrom = (db: Knex) => async (): Promise<UserRecord[]> => {
+  return await db<UserRecord>("users").select();
 };
 
-export const queryResourceAcl = async ({
-  resourceId,
-  userId,
-}: {
-  resourceId: string;
-  userId: string;
-}): Promise<ResourceAcl | null> => {
-  return (
-    (await ResourceAclRepo()
-      .where("userId", "=", userId)
-      .andWhere("resourceId", "=", resourceId)
-      .first()) ?? null
-  );
-};
+export const saveUserTo =
+  (db: Knex) =>
+  async (user: UserRecord): Promise<void> => {
+    await db<UserRecord>("users").insert(user);
+  };
+
+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 });
@@ -54,23 +86,115 @@ export const queryResources = async ({
   return await query.limit(limit);
 };
 
-export const countComments = async (resourceId: string): Promise<number> => {
-  const [rawCount] = await Comments().count().where({ resourceId });
-  return parseInt(rawCount.count as string);
-};
+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 queryComments = async ({
-  resourceId,
-  limit,
-  cursor,
-}: {
-  resourceId: string;
-  limit: number;
-  cursor: string | null;
-}): Promise<Comment[]> => {
-  const query = Comments().where({ resourceId });
-  if (cursor) {
-    query.andWhere("createdAt", "<", cursor);
-  }
-  return await query.limit(limit);
-};
+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;

src/resolvers.ts

@@ -1,26 +1,63 @@
-import { queryResourceAcl } from "./repositories";
-import { getUser, getResource, getComments, getResources } from "./services";
+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 { 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 getUser(args.id);
+      return await queryUser(args.id);
     },
     async resource(
       _: unknown,
       args: { id: string; userId: string },
     ): Promise<Resource> {
-      const maybeAcl = await queryResourceAcl({
+      const mainDb = getMainDbClient();
+      const maybeAcl = await queryResourceAclFrom(mainDb)({
         userId: args.userId,
         resourceId: args.id,
       });
@@ -34,7 +71,8 @@ export const resolvers = {
           },
         );
       }
-      const maybeResource = await getResource(args.id);
+      const db = await getResourceDatabaseConnection(args.id);
+      const maybeResource = await queryResourceFrom(db)(args.id);
       if (maybeResource == null) {
         throw new GraphQLError("Resource not found", {
           extensions: { code: "RESOURCE_NOT_FOUND" },
@@ -42,6 +80,12 @@ export const resolvers = {
       }
       return maybeResource;
     },
+    async organizations() {
+      return await getOrganizationsFrom(getMainDbClient())();
+    },
+    async regions() {
+      return await getRegionsFrom(getMainDbClient())();
+    },
   },
   User: {
     async resources(parent: UserRecord, args: PaginationArgs) {
@@ -53,11 +97,100 @@ export const resolvers = {
       parent: Resource,
       { limit, cursor }: PaginationArgs,
     ): Promise<CommentCollection> {
-      return await getComments({
+      const db = await getResourceDatabaseConnection(parent.id);
+      return await getComments(
+        countCommentsIn(db),
+        queryCommentsFrom(db),
+      )({
         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,8 +30,59 @@ 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

@@ -1,61 +0,0 @@
-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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,242 @@
+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> => {
+  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

@@ -0,0 +1,45 @@
+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,11 +1,14 @@
-export interface Comment {
-  id: string;
+export interface CommentCreateArgs {
   userId: string;
   content: string;
-  createdAt: Date;
   resourceId: string;
 }
 
+export interface Comment extends CommentCreateArgs {
+  id: string;
+  createdAt: Date;
+}
+
 export interface PaginationArgs {
   limit: number;
   cursor: string | null;
@@ -19,6 +22,16 @@ interface Collection<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 Resource {
   id: string;
   name: string;
@@ -27,11 +40,14 @@ export interface Resource {
 
 export interface ResourceCollection extends Collection<Resource> {}
 
-export interface UserRecord {
-  id: string;
+export interface UserCreateArgs {
   name: string;
 }
 
+export interface UserRecord extends UserCreateArgs {
+  id: string;
+}
+
 export interface User extends UserRecord {
   resources: {
     cursor: string | null;
@@ -44,3 +60,39 @@ export interface ResourceAcl {
   userId: string;
   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;
+  resourceId: string;
+}
+
+export interface ResourceRegion {
+  resourceId: string;
+  regionId: string;
+}
+
+export interface ResourceRegionOrg extends ResourceRegion {
+  organizationId: string;
+}