rework naming

Rhys Sullivan committed 7 months ago

Commit da613211 parent f0c45e713 files · +310 −304Browse files

Showing the changes to examples (1 of 13 files). Show all

Unified · Split

examples/sqlite-sdk-consumer/src/sqlite-backend.ts+90−87

 import {
   createExecutorBackend,
   type ExecutorBackend,
-  type ExecutorBackendServices,
+  type ExecutorBackendRepositories,
-  type ExecutorScopeConfigBackend,
+  type ExecutorWorkspaceConfigRepository,
-  type ExecutorScopeStateBackend,
+  type ExecutorWorkspaceStateRepository,
-  type ExecutorSourceArtifactBackend,
+  type ExecutorWorkspaceSourceArtifactRepository,
 } from "@executor/platform-sdk";
 import type {
   AuthArtifact,
   actorScopeId?: string;
 };
-type ScopeConfig = Awaited<ReturnType<ExecutorScopeConfigBackend["load"]>>;
+type ScopeConfig = Awaited<ReturnType<ExecutorWorkspaceConfigRepository["load"]>>;
-type ScopeState = Awaited<ReturnType<ExecutorScopeStateBackend["load"]>>;
+type ScopeState = Awaited<ReturnType<ExecutorWorkspaceStateRepository["load"]>>;
-type SourceArtifact = ReturnType<ExecutorSourceArtifactBackend["build"]>;
+type SourceArtifact =
-type SourceArtifactBuildInput = Parameters<ExecutorSourceArtifactBackend["build"]>[0];
+  ReturnType<ExecutorWorkspaceSourceArtifactRepository["build"]>;
+type SourceArtifactBuildInput = Parameters<
+  ExecutorWorkspaceSourceArtifactRepository["build"]
+>[0];
 type SecretMaterialSummary = {
   id: string;
     : (options.databasePath ?? ":memory:");
   return createExecutorBackend({
-    loadServices: () => {
+    loadRepositories: () => {
       const store = openSqliteStore(databasePath);
       const { auth, secrets, executions } = createStorageDomains(store);
             databasePath,
           },
         },
-        storage: {
+        installation: {
-          installation: {
+          load: () => {
-            load: () => {
+            const row = store.db.select().from(installations).where(eq(installations.key, "active")).get();
+            return row
+              ? {
+                  scopeId: row.scopeId as LocalInstallation["scopeId"],
+                  actorScopeId: row.actorScopeId as LocalInstallation["actorScopeId"],
+                  resolutionScopeIds: parseJson<LocalInstallation["resolutionScopeIds"]>(
+                    row.resolutionScopeIdsJson,
+                  ),
+                }
+              : createInstallation(options);
+          },
+          getOrProvision: () => {
+            const installation = (() => {
               const row = store.db.select().from(installations).where(eq(installations.key, "active")).get();
               return row
                 ? {
                     ),
                   }
                 : createInstallation(options);
-            },
+            })();
-            getOrProvision: () => {
+            store.db.insert(installations).values({
-              const installation = (() => {
+              key: "active",
-                const row = store.db.select().from(installations).where(eq(installations.key, "active")).get();
+              scopeId: installation.scopeId,
-                return row
+              actorScopeId: installation.actorScopeId,
-                  ? {
+              resolutionScopeIdsJson: JSON.stringify(installation.resolutionScopeIds),
-                      scopeId: row.scopeId as LocalInstallation["scopeId"],
+            }).onConflictDoUpdate({
-                      actorScopeId: row.actorScopeId as LocalInstallation["actorScopeId"],
+              target: installations.key,
-                      resolutionScopeIds: parseJson<LocalInstallation["resolutionScopeIds"]>(
+              set: {
-                        row.resolutionScopeIdsJson,
-                      ),
-                    }
-                  : createInstallation(options);
-              })();
-              store.db.insert(installations).values({
-                key: "active",
                 scopeId: installation.scopeId,
                 actorScopeId: installation.actorScopeId,
                 resolutionScopeIdsJson: JSON.stringify(installation.resolutionScopeIds),
-              }).onConflictDoUpdate({
+              },
-                target: installations.key,
+            }).run();
-                set: {
+            return installation;
-                  scopeId: installation.scopeId,
-                  actorScopeId: installation.actorScopeId,
-                  resolutionScopeIdsJson: JSON.stringify(installation.resolutionScopeIds),
-                },
-              }).run();
-              return installation;
-            },
           },
-          scopeConfig: {
+        },
+        workspace: {
+          config: {
             load: () => {
               const row = store.db.select().from(scopeConfigs).where(eq(scopeConfigs.key, "project")).get();
               const projectConfig = row
             },
             resolveRelativePath: ({ path, scopeRoot }) => resolvePath(scopeRoot, path),
           },
-          scopeState: {
+          state: {
             load: () => {
               const row = store.db.select().from(scopeStates).where(eq(scopeStates.key, "active")).get();
               return row ? parseJson<ScopeState>(row.stateJson) : defaultScopeState();
               store.db.delete(sourceArtifacts).where(eq(sourceArtifacts.sourceId, sourceId)).run();
             },
           },
-          auth,
+          sourceAuth: auth,
-          secrets: {
+        },
-            ...secrets,
+        secrets: {
-            resolve: ({ ref }) => {
+          ...secrets,
-              const material = secrets.getById(
+          resolve: ({ ref }) => {
-                ref.handle as SecretMaterial["id"],
+            const material = secrets.getById(
-              );
+              ref.handle as SecretMaterial["id"],
-              if (!material || material.value === null) {
+            );
-                throw new Error(`Missing secret material ${ref.handle}`);
+            if (!material || material.value === null) {
-              }
+              throw new Error(`Missing secret material ${ref.handle}`);
-              return material.value;
+            }
-            },
+            return material.value;
-            store: ({ purpose, value, name, providerId }) => {
-              const now = Date.now();
-              const id = SecretMaterialIdSchema.make(`secret_${randomUUID()}`);
-              const material: SecretMaterial = {
-                id,
-                providerId: providerId ?? SQLITE_SECRET_PROVIDER_ID,
-                handle: id,
-                name: name ?? null,
-                purpose,
-                value,
-                createdAt: now,
-                updatedAt: now,
-              };
-              secrets.upsert(material);
-              return {
-                providerId: material.providerId,
-                handle: material.handle,
-              } satisfies SecretRef;
-            },
-            delete: (ref) =>
-              secrets.removeById(ref.handle as SecretMaterial["id"]),
-            update: ({ ref, name, value }) => {
-              const updated = secrets.updateById(
-                ref.handle as SecretMaterial["id"],
-                { name, value },
-              );
-              if (!updated) {
-                throw new Error(`Missing secret material ${ref.handle}`);
-              }
-              return updated;
-            },
           },
-          executions,
+          store: ({ purpose, value, name, providerId }) => {
-          close: async () => {
+            const now = Date.now();
-            store.close();
+            const id = SecretMaterialIdSchema.make(`secret_${randomUUID()}`);
+            const material: SecretMaterial = {
+              id,
+              providerId: providerId ?? SQLITE_SECRET_PROVIDER_ID,
+              handle: id,
+              name: name ?? null,
+              purpose,
+              value,
+              createdAt: now,
+              updatedAt: now,
+            };
+            secrets.upsert(material);
+            return {
+              providerId: material.providerId,
+              handle: material.handle,
+            } satisfies SecretRef;
+          },
+          delete: (ref) =>
+            secrets.removeById(ref.handle as SecretMaterial["id"]),
+          update: ({ ref, name, value }) => {
+            const updated = secrets.updateById(
+              ref.handle as SecretMaterial["id"],
+              { name, value },
+            );
+            if (!updated) {
+              throw new Error(`Missing secret material ${ref.handle}`);
+            }
+            return updated;
           },
         },
+        executions,
         instanceConfig: {
           resolve: () => ({
             platform: "sqlite-sdk-example",
             defaultSecretStoreProvider: SQLITE_SECRET_PROVIDER_ID,
           }),
         },
-      } satisfies ExecutorBackendServices;
+        close: async () => {
+          store.close();
+        },
+      } satisfies ExecutorBackendRepositories;
     },
   });
 };