@kamilio/wire 0.1.3 → 0.1.4

package/src/executable.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 
 import { createRoot } from "./adapters/root.js";
 import { composeAuth } from "./auth.js";
@@ -52,15 +52,21 @@ function loadConfiguredEnvironment(environment: NodeEnvironment, currentDirector
   return config.env === undefined ? environment : Object.freeze({ ...environment, ...config.env });
 }
 
+function operationPath(value: string, path: string): string {
+  if (value.startsWith("http://") || value.startsWith("https://")) return path;
+  return isAbsolute(value) ? value : resolve(path, value);
+}
+
 export function createExecutableRoot(environment: NodeEnvironment, currentDirectory: string, options = { allowPaste: true }) {
   const repositoryRoot = environment["WIRE_REPOSITORY_ROOT"] ?? discoverRepositoryRoot(currentDirectory);
   const baseEnvironment = repositoryRoot === undefined ? environment : Object.freeze({ ...environment, WIRE_REPOSITORY_ROOT: repositoryRoot });
-  const resolvedEnvironment = loadConfiguredEnvironment(baseEnvironment, currentDirectory);
+  let activeConfigurationPath = currentDirectory;
+  const configuredEnvironment = () => loadConfiguredEnvironment(baseEnvironment, activeConfigurationPath);
   const http = createNodeHttp();
   const filesystem = createNodeFilesystem();
   const processCapability = createNodeProcess();
   const clock = createNodeClock();
-  const configuration = createNodeConfiguration(resolvedEnvironment);
+  const configuration = Object.freeze({ get: (name: string) => createNodeConfiguration(configuredEnvironment()).get(name) });
   const home = configuration.get("HOME");
   const runtimeBase = {
     http,
@@ -69,14 +75,14 @@ export function createExecutableRoot(environment: NodeEnvironment, currentDirect
     clock,
     openFiles: createNodeOpenFiles(processCapability),
     configuration,
-    secrets: createNodeSecrets(filesystem, resolvedEnvironment),
+    secrets: createNodeSecrets(filesystem, configuredEnvironment()),
     gmailTokens: Object.freeze({ load: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).load(), refresh: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).refresh() }),
     googleFormsTokens: Object.freeze({ load: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).load(), refresh: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).refresh() }),
   };
   let auth: ReturnType<typeof composeAuth>;
-  const runtime = Object.freeze({ ...runtimeBase, cookies: createCookiesCapability(filesystem, () => home, () => resolvedEnvironment["WIRE_REPOSITORY_ROOT"]) });
-  auth = composeAuth(runtime, resolvedEnvironment, extractChromeCookies);
-  const wire = withWireHooks(composeWire({
+  const runtime = Object.freeze({ ...runtimeBase, cookies: createCookiesCapability(filesystem, () => home, () => configuredEnvironment()["WIRE_REPOSITORY_ROOT"]) });
+  auth = composeAuth(runtime, configuredEnvironment(), extractChromeCookies);
+  const baseWire = composeWire({
     home,
     fetchInput: runtime,
     catalog: serviceCatalog,
@@ -98,6 +104,25 @@ export function createExecutableRoot(environment: NodeEnvironment, currentDirect
     watch: createNodeWatch(),
     now: runtime.clock.now,
     open: runtime.openFiles.open,
-  }), { currentDirectory, home, environment: resolvedEnvironment });
+  });
+  const configuredWire = Object.freeze({
+    ...baseWire,
+    attach: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.attach(url, path); },
+    create: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.create(url, path); },
+    view: async (url: string) => { activeConfigurationPath = currentDirectory; return baseWire.view(url); },
+    downloadSource: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.downloadSource(url, path); },
+    sync: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.sync(value, path); },
+    download: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.download(value, path); },
+    detach: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.detach(value, path); },
+    unlink: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.unlink(value, path); },
+    watch: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.watch(value, path); },
+    openResource: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.openResource(value, path); },
+    syncAll: async (path: string) => { activeConfigurationPath = path; return baseWire.syncAll(path); },
+    listResources: async (path: string) => { activeConfigurationPath = path; return baseWire.listResources(path); },
+    showResource: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.showResource(value, path); },
+    init: baseWire.init,
+    switchBackend: baseWire.switchBackend,
+  });
+  const wire = withWireHooks(configuredWire, { currentDirectory, home, environment: configuredEnvironment() });
   return createRoot(wire, currentDirectory, auth, readStandardInput, options);
 }

package/src/hooks.ts

@@ -5,7 +5,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 
 import type { Resource, Wire, WireResult } from "wire-core";
-import { configuredWireRoot, openWireRegistry, wireRelativePath } from "wire-core";
+import { configuredWireRoot, loadWireConfig, openWireRegistry, wireRelativePath } from "wire-core";
 import type { WireWatchSyncHook } from "wire-core/internal/operations";
 import { wireWatchHooks } from "wire-core/internal/operations";
 
@@ -118,10 +118,18 @@ async function updateMovedResult(options: WireHookOptions, wireRoot: string, res
       { ...primary, path: relativePath },
     ],
   };
-  if (result.summary.action !== "detached") await (await openWireRegistry(wireRoot, options.home)).put(resource);
+  if (result.summary.action !== "detached") {
+    const registry = await openWireRegistry(wireRoot, options.home);
+    if ((await registry.listResources()).some((item) => item.id === result.resource.id)) await registry.put(resource);
+  }
   return { ...result, resource, path: outputPath, summary: { ...result.summary, local: outputPath } };
 }
 
+async function hookEnvironment(options: WireHookOptions, wireRoot: string): Promise<Record<string, string>> {
+  const config = await loadWireConfig(wireRoot);
+  return stringEnvironment({ ...options.environment, ...config.env });
+}
+
 async function runHookCommands(wireRoot: string, event: WireHookEvent, environment: Readonly<Record<string, string>>): Promise<Record<string, string>> {
   let current = { ...environment };
   for (const path of await hookCommandPaths(wireRoot, event)) {
@@ -132,10 +140,11 @@ async function runHookCommands(wireRoot: string, event: WireHookEvent, environme
 }
 
 async function runResourceHooks(options: WireHookOptions, command: string, result: WireResult): Promise<HookState> {
-  const wireRoot = (await configuredWireRoot(result.path, options.home))!;
+  const wireRoot = await configuredWireRoot(result.path, options.home);
+  if (wireRoot === null) return { result, environment: {} };
   let currentResult = result;
   let environment = {
-    ...stringEnvironment(options.environment),
+    ...await hookEnvironment(options, wireRoot),
     ...resourceEnvironment(command, options.currentDirectory, wireRoot, currentResult),
   };
   for (const path of await hookCommandPaths(wireRoot, "post-resource")) {
@@ -152,9 +161,10 @@ async function runResourceHooks(options: WireHookOptions, command: string, resul
 }
 
 async function runSummaryHooks(options: WireHookOptions, event: WireHookEvent, command: string, rootPath: string, results: readonly WireResult[], environment: Readonly<Record<string, string>>): Promise<Record<string, string>> {
-  const wireRoot = (await configuredWireRoot(rootPath, options.home))!;
+  const wireRoot = await configuredWireRoot(rootPath, options.home);
+  if (wireRoot === null) return {};
   return runHookCommands(wireRoot, event, {
-    ...stringEnvironment(options.environment),
+    ...await hookEnvironment(options, wireRoot),
     ...environment,
     ...summaryEnvironment(event, command, options.currentDirectory, wireRoot, results),
   });