add environment support

Author: hazelnutcloud

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "deno.enable": true,
+  "deno.unstable": true
+}

manager/.env.sample

@@ -11,4 +11,5 @@ GRAPHQL_SERVER_PORT=
 INFLUX_URL=
 INFLUX_TOKEN=
 INFLUX_ORG=
-INFLUX_BUCKET=
+INFLUX_BUCKET=
+ENVIRONMENT= # dev | staging | prod

manager/deno.lock

@@ -39,7 +39,8 @@ if (import.meta.main) {
 		},
 	})
 	logger('manager').info('Starting Arkiver...')
-	const dev = Deno.env.get('DEV') !== undefined
-	const manager = new ArkiveManager({ dev })
+	const environment = Deno.env.get('ENVIRONMENT')
+	if (!environment) throw new Error('ENVIRONMENT not set')
+	const manager = new ArkiveManager({ environment })
 	await manager.init()
 }

manager/main.ts

@@ -17,13 +17,14 @@ export class ArkiveManager {
 	private arkives: { arkive: arkiverTypes.Arkive; worker: Worker }[] = []
 	private rpcUrls: Record<string, string>
 
-	constructor(params: { dev: boolean }) {
+	constructor(params: { environment: string }) {
 		this.removeAllArkives = this.removeAllArkives.bind(this)
 		this.addNewArkive = this.addNewArkive.bind(this)
 
-		this.arkiveProvider = params.dev
+		const environment = params.environment.toLowerCase()
+		this.arkiveProvider = environment === "dev"
 			? new LocalArkiveProvider()
-			: new SupabaseProvider()
+			: new SupabaseProvider({ environment })
 		this.dataProvider = new MongoDataProvider()
 		this.graphQLServer = new GraphQLServer(this.arkiveProvider) // TODO implement GraphQL server
 		this.rpcUrls = collectRpcUrls()
@@ -151,7 +152,7 @@ export class ArkiveManager {
 						// check if previous version is an older major version
 						if (
 							previousVersion.arkive.deployment.major_version <
-								arkive.deployment.major_version
+							arkive.deployment.major_version
 						) {
 							logger('manager').info(
 								'removing old major version',
@@ -198,9 +199,9 @@ export class ArkiveManager {
 				a.arkive.id === arkive.id && // same id
 				(a.arkive.deployment.major_version < arkive.deployment.major_version || // older major version
 					(a.arkive.deployment.major_version === // same major version but older minor version
-							arkive.deployment.major_version &&
+						arkive.deployment.major_version &&
 						a.arkive.deployment.minor_version <
-							arkive.deployment.minor_version)),
+						arkive.deployment.minor_version)),
 		)
 	}
 

manager/packages/manager/manager.ts

@@ -1,12 +1,12 @@
 import { ArkiveProvider } from './interfaces.ts'
 import {
-	arkiver,
 	arkiverTypes,
 	path as denoPath,
 	supabase,
 } from '../../deps.ts'
 import { getEnv, getSupabaseClient, rm, unpack } from '../utils.ts'
 import { arkivesDir } from '../manager/manager.ts'
+import { logger } from '../logger.ts'
 
 interface RawArkive extends Omit<arkiverTypes.Arkive, 'deployment'> {
 	deployments: arkiverTypes.Deployment[]
@@ -16,15 +16,18 @@ export class SupabaseProvider implements ArkiveProvider {
 	private supabase: supabase.SupabaseClient
 	private newArkiveListener?: supabase.RealtimeChannel
 	private deletedArkiveListener?: supabase.RealtimeChannel
+	private environment: string
 
-	constructor() {
+	constructor(params: { environment: string }) {
 		this.supabase = getSupabaseClient()
+		this.environment = params.environment
 	}
 
 	public async getArkives(): Promise<arkiverTypes.Arkive[]> {
 		const arkivesRes = await this.supabase
 			.from(getEnv('SUPABASE_ARKIVE_TABLE'))
 			.select<'*, deployments(*)', RawArkive>('*, deployments(*)')
+			.eq('environment', this.environment)
 
 		if (arkivesRes.error) {
 			throw arkivesRes.error
@@ -82,19 +85,20 @@ export class SupabaseProvider implements ArkiveProvider {
 					)
 						.select<'*', Omit<arkiverTypes.Arkive, 'deployment'>>('*')
 						.eq('id', payload.new.arkive_id)
-						.single()
+						.eq('environment', this.environment)
 					if (e) {
 						const error = {
 							...e,
 							name: 'SupabaseProvider.listenNewArkive',
 						} satisfies Error
-						arkiver.logger().error(error, {
+						logger('manager').error(error, {
 							source: 'SupabaseProvider.listenNewArkive',
 						})
 						return
 					}
+					if (data.length === 0) return
 					const newArkive = {
-						...data,
+						...data[0],
 						deployment: payload.new,
 					}
 					await callback(newArkive)
@@ -189,6 +193,6 @@ export class SupabaseProvider implements ArkiveProvider {
 		if (this.deletedArkiveListener) {
 			this.deletedArkiveListener.unsubscribe()
 		}
-		arkiver.logger().info('closed')
+		logger('manager').info('closed')
 	}
 }

manager/packages/providers/supabase.ts

@@ -39,7 +39,7 @@ export const collectRpcUrls = () => {
 	for (const chain of Object.keys(arkiver.supportedChains)) {
 		try {
 			rpcUrls[chain] = getEnv(`${chain.toUpperCase()}_RPC_URL`)
-		} catch (e) {}
+		} catch (e) { }
 	}
 	return rpcUrls
 }

manager/packages/utils.ts

@@ -11,14 +11,15 @@ type PostParams = Partial<
     isPublic: string;
     update: "major" | "minor";
     manifest: any;
+    env?: string;
   }
 >;
 
 export const post = async (
   supabase: SupabaseClient,
   params: PostParams,
 ) => {
-  const { userId, name, pkg, isPublic, update, manifest } = params;
+  const { userId, name, pkg, isPublic, update, manifest, env } = params;
   const parsedManifest = JSON.parse(manifest);
   // check params
   if (!userId || !name || !pkg) {
@@ -29,12 +30,13 @@ export const post = async (
   const selectRes = await supabase
     .from(getEnv("ARKIVE_TABLE"))
     .select<
-      "id, deployments(major_version, minor_version)",
+      "id, env, deployments(major_version, minor_version)",
       {
         id: string;
+        env: string;
         deployments: { major_version: number; minor_version: number }[];
       }
-    >("id, deployments(major_version, minor_version)")
+    >("id, env, deployments(major_version, minor_version)")
     .eq("user_id", userId)
     .eq("name", name);
 
@@ -54,16 +56,20 @@ export const post = async (
         userId,
         update,
         manifest: parsedManifest,
+        env
       },
     );
   } else {
     return await createDeployment(
-      supabase,
-      userId,
-      name,
-      pkg,
-      isPublic,
-      parsedManifest,
+      {
+        supabase,
+        userId,
+        name,
+        pkg,
+        isPublic,
+        manifest: parsedManifest,
+        env
+      }
     );
   }
 };
@@ -73,16 +79,18 @@ const updateDeployment = async (
   arkive: {
     id: string;
     deployments: { major_version: number; minor_version: number }[];
+    env: string;
   },
   params: {
     userId: string;
     pkg: File;
     update: "major" | "minor";
     manifest: any;
+    env?: string;
   },
 ) => {
   // check params
-  const { userId, pkg, update, manifest } = params;
+  const { userId, pkg, update, manifest, env } = params;
   if (
     (update !== "major" && update !== "minor")
   ) {
@@ -147,24 +155,43 @@ const updateDeployment = async (
     throw insertRes.error;
   }
 
+  if (env && env !== arkive.env) {
+    const updateRes = await supabase
+      .from(getEnv("ARKIVE_TABLE"))
+      .update<{ env: string }>({
+        env,
+      })
+      .eq("id", arkive.id);
+
+    if (updateRes.error) {
+      throw updateRes.error;
+    }
+  }
+
   return insertRes.data;
 };
 
 const createDeployment = async (
-  supabase: SupabaseClient,
-  userId: string,
-  name: string,
-  pkg: File,
-  isPublic: string | undefined,
-  manifest: any,
+  params: {
+    supabase: SupabaseClient,
+    userId: string,
+    name: string,
+    pkg: File,
+    isPublic: string | undefined,
+    manifest: any,
+    env?: string
+  }
 ) => {
+  const { supabase, userId, name, pkg, isPublic, manifest, env } = params;
+
   // insert new row to arkive table
   const insertArkiveRes = await supabase
     .from(getEnv("ARKIVE_TABLE"))
     .insert({
       user_id: userId,
       name,
       public: isPublic !== undefined,
+      env: env ?? "staging",
     })
     .select<"id", { id: string }>("id");