remove scopeRoot / scopeName

Rhys Sullivan committed 7 months ago

Commit a7601031 parent 7dd9a5d10 files · +13 −45Browse files

Unified · Split

10 files

examples/sqlite-sdk-consumer/README.md +0 −1
examples/sqlite-sdk-consumer/src/main.ts +0 −2
examples/sqlite-sdk-consumer/src/sqlite-backend.ts +6 −8
packages/platform/sdk-file/src/index.ts +0 −5
packages/platform/sdk/src/backend.ts +0 −1
packages/platform/sdk/src/policies/operations.ts +7 −22
packages/platform/sdk/src/runtime/execution/scope/source-catalog.test.ts +0 −1
packages/platform/sdk/src/runtime/index.ts +0 −2
packages/platform/sdk/src/runtime/scope/storage.ts +0 −1
packages/platform/sdk/src/scope.ts +0 −2

examples/sqlite-sdk-consumer/README.md+0−1

@@ -36,7 +36,6 @@ import { createSqliteExecutorBackend } from "@executor/sqlite-sdk-consumer-examp · 35 unmodified lines
36	const executor = await createExecutor({	36	const executor = await createExecutor({
37	backend: createSqliteExecutorBackend({	37	backend: createSqliteExecutorBackend({
38	databasePath: "./executor.sqlite",	38	databasePath: "./executor.sqlite",
39	scopeName: "Acme",
40	}),	39	}),
41	});	40	});
42	```	41	```

examples/sqlite-sdk-consumer/src/main.ts+0−2

@@ -8,8 +8,6 @@ const databasePath = process.env.DATABASE_PATH · 7 unmodified lines
8	const executor = await createExecutor({	8	const executor = await createExecutor({
9	backend: createSqliteExecutorBackend({	9	backend: createSqliteExecutorBackend({
10	databasePath,	10	databasePath,
11	scopeName: "SQLite Example Workspace",
12	scopeRoot: process.cwd(),
13	}),	11	}),
14	});	12	});
15		13

examples/sqlite-sdk-consumer/src/sqlite-backend.ts+6−8

   Execution,
   ExecutionInteraction,
   ExecutionStep,
-  LocalExecutorConfig,
+  ExecutorScopeConfig,
   LocalInstallation,
   SecretMaterial,
   SecretRef,
   SourceCatalogIdSchema,
   SourceCatalogRevisionIdSchema,
 } from "@executor/platform-sdk/schema";
+import type {
+  SecretMaterialStoredDataRecord,
+} from "@executor/platform-sdk/runtime";
 import {
   contentHash,
   snapshotFromSourceCatalogSyncResult,
 export type CreateSqliteExecutorBackendOptions = {
   databasePath?: string;
-  scopeName?: string;
-  scopeRoot?: string | null;
   scopeId?: string;
   actorScopeId?: string;
 };
             }
           : null;
       },
-      upsert: (record: { secretId: SecretMaterial["id"]; data: unknown }) => {
+      upsert: (record: SecretMaterialStoredDataRecord) => {
         store.db.insert(secretMaterialStoredData).values({
           secretId: record.secretId,
           json: JSON.stringify(record.data),
       return {
         scope: {
-          scopeName: options.scopeName ?? "SQLite SDK Example",
-          scopeRoot: options.scopeRoot ?? null,
           metadata: {
             kind: "sqlite",
             databasePath,
             load: () => {
               const row = store.db.select().from(scopeConfigs).where(eq(scopeConfigs.key, "project")).get();
               const projectConfig = row
-                ? parseJson<LocalExecutorConfig>(row.projectConfigJson)
+                ? parseJson<ExecutorScopeConfig>(row.projectConfigJson)
                 : {};
               return {
                 config: projectConfig,
                 set: { projectConfigJson: JSON.stringify(config) },
               }).run();
             },
-            resolveRelativePath: ({ path, scopeRoot }) => resolvePath(scopeRoot, path),
           },
           state: {
             load: () => {

packages/platform/sdk-file/src/index.ts+0−5

   type LoadedExecutorScopeConfig,
   type ResolvedLocalWorkspaceContext,
   loadExecutorScopeConfig,
-  resolveConfigRelativePath,
   resolveLocalWorkspaceContext,
   writeProjectExecutorScopeConfig,
 } from "./config";
 ): {
   load: () => Effect.Effect<LoadedExecutorScopeConfig, Error, never>;
   writeProject: (config: ExecutorScopeConfig) => Effect.Effect<void, Error, never>;
-  resolveRelativePath: typeof resolveConfigRelativePath;
 } => ({
   load: () =>
     bindFileSystem(fileSystem, loadExecutorScopeConfig(context)).pipe(
       fileSystem,
       writeProjectExecutorScopeConfig({ context, config }),
     ).pipe(Effect.mapError(toError)),
-  resolveRelativePath: resolveConfigRelativePath,
 });
 const createBoundWorkspaceStateStore = (
 const toExecutorScopeContext = (
   context: ResolvedLocalWorkspaceContext,
 ): ExecutorScopeDescriptor => ({
-  scopeName: context.workspaceName,
-  scopeRoot: context.workspaceRoot,
   metadata: {
     kind: "file",
     configDirectory: context.configDirectory,

packages/platform/sdk/src/backend.ts+0−1

@@ -125,7 +125,6 @@ const toScopeConfigBackend = ( · 124 unmodified lines
125	): BoundScopeConfigStore => ({	125	): BoundScopeConfigStore => ({
126	load: () => toEffect(input.load()),	126	load: () => toEffect(input.load()),
127	writeProject: (config) => toEffect(input.writeProject(config)),	127	writeProject: (config) => toEffect(input.writeProject(config)),
128	resolveRelativePath: input.resolveRelativePath,
129	});	128	});
130		129
131	const toScopeStateBackend = (	130	const toScopeStateBackend = (

packages/platform/sdk/src/policies/operations.ts+7−22

 const cloneJson = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;
-const scopePolicyStableKey = (input: {
+const scopePolicyStableKey = (scopeId: ScopeId): string => scopeId;
-  scopeId: ScopeId;
-  scopeRoot?: string | null;
-}): string => input.scopeRoot?.trim() || input.scopeId;
 const localPolicyIdForKey = (input: {
   scopeStableKey: string;
       ([key, policyConfig]) =>
         toLocalScopePolicy({
           scopeId,
-          scopeStableKey: scopePolicyStableKey({
+          scopeStableKey: scopePolicyStableKey(scopeId),
-            scopeId,
-            scopeRoot: runtimeLocalScope.scope.scopeRoot,
-          }),
           key,
           policyConfig,
           state: scopeState.policies[key],
   payload: CreatePolicyPayload;
 }) =>
   Effect.gen(function* () {
-    const runtimeLocalScope = yield* loadScopePolicyContext(
+    yield* loadScopePolicyContext(
       policyOps.create,
       input.scopeId,
     );
           id:
             existingState?.id ??
             localPolicyIdForKey({
-              scopeStableKey: scopePolicyStableKey({
+              scopeStableKey: scopePolicyStableKey(input.scopeId),
-                scopeId: input.scopeId,
-                scopeRoot: runtimeLocalScope.scope.scopeRoot,
-              }),
               key,
             }),
           createdAt: existingState?.createdAt ?? now,
     return toLocalScopePolicy({
       scopeId: input.scopeId,
-      scopeStableKey: scopePolicyStableKey({
+      scopeStableKey: scopePolicyStableKey(input.scopeId),
-        scopeId: input.scopeId,
-        scopeRoot: runtimeLocalScope.scope.scopeRoot,
-      }),
       key,
       policyConfig: policies[key]!,
       state: scopeState.policies[key],
   payload: UpdatePolicyPayload;
 }) =>
   Effect.gen(function* () {
-    const runtimeLocalScope = yield* loadScopePolicyContext(
+    yield* loadScopePolicyContext(
       policyOps.update,
       input.scopeId,
     );
     return toLocalScopePolicy({
       scopeId: input.scopeId,
-      scopeStableKey: scopePolicyStableKey({
+      scopeStableKey: scopePolicyStableKey(input.scopeId),
-        scopeId: input.scopeId,
-        scopeRoot: runtimeLocalScope.scope.scopeRoot,
-      }),
       key: existing.key,
       policyConfig: policies[existing.key]!,
       state: scopeState.policies[existing.key],

packages/platform/sdk/src/runtime/execution/scope/source-catalog.test.ts+0−1

@@ -53,7 +53,6 @@ const makeLoadedCatalog = (input: { · 52 unmodified lines
53	const noopScopeConfigStore = {	53	const noopScopeConfigStore = {
54	load: () => Effect.die("unexpected config load"),	54	load: () => Effect.die("unexpected config load"),
55	writeProject: () => Effect.void,	55	writeProject: () => Effect.void,
56	resolveRelativePath: (path: string) => Effect.succeed(path),
57	} as any;	56	} as any;
58		57
59	const noopScopeStateStore = {	58	const noopScopeStateStore = {

packages/platform/sdk/src/runtime/index.ts+0−2

   writeProject: (
     config: ExecutorScopeConfig,
   ) => Effect.Effect<void, Error, never>;
-  resolveRelativePath: ScopeConfigStoreShape["resolveRelativePath"];
 };
 export type BoundScopeStateStore = {
 ): ScopeConfigStoreShape => ({
   load: input.load,
   writeProject: ({ config }) => input.writeProject(config),
-  resolveRelativePath: input.resolveRelativePath,
 });
 const toScopeStateStoreShape = (

packages/platform/sdk/src/runtime/scope/storage.ts+0−1

@@ -35,7 +35,6 @@ export type ScopeConfigStoreShape = { · 34 unmodified lines
35	writeProject: (input: {	35	writeProject: (input: {
36	config: ExecutorScopeConfig;	36	config: ExecutorScopeConfig;
37	}) => import("effect/Effect").Effect<void, Error, never>;	37	}) => import("effect/Effect").Effect<void, Error, never>;
38	resolveRelativePath: (input: { path: string; scopeRoot: string }) => string;
39	};	38	};
40		39
41	export class ScopeConfigStore extends Context.Tag(	40	export class ScopeConfigStore extends Context.Tag(

packages/platform/sdk/src/scope.ts+0−2

@@ -3,8 +3,6 @@ import type { · 2 unmodified lines
3	} from "./schema";	3	} from "./schema";
4		4
5	export type ExecutorScopeDescriptor = {	5	export type ExecutorScopeDescriptor = {
6	scopeName: string;
7	scopeRoot?: string \| null;
8	actorScopeId?: ScopeId \| null;	6	actorScopeId?: ScopeId \| null;
9	resolutionScopeIds?: ReadonlyArray<ScopeId>;	7	resolutionScopeIds?: ReadonlyArray<ScopeId>;
10	metadata?: Readonly<Record<string, unknown>>;	8	metadata?: Readonly<Record<string, unknown>>;