chore: unify private member naming conventions

Author: dOrgJelli

packages/cli/src/lib/defaults/infra-modules/http/server/src/utils/zip.ts

@@ -8,7 +8,7 @@ export class Zip {
     this._zip = new JSZip();
   }
 
-  private generateNodeZip(filePath: string) {
+  private _generateNodeZip(filePath: string) {
     return new Promise<boolean>((res, rej) => {
       this._zip.generateNodeStream({ type: 'nodebuffer', streamFiles: true })
           .pipe(fse.createWriteStream(filePath))
@@ -25,6 +25,6 @@ export class Zip {
     fse.readdirSync(sourceDir).forEach(file => {
       this._zip.file(file, fse.readFileSync(`${sourceDir}/${file}`))
     })
-    return this.generateNodeZip(outputPath);
+    return this._generateNodeZip(outputPath);
   }
 }

packages/cli/src/lib/deploy/Deployer.ts

@@ -77,11 +77,11 @@ export class Deployer {
 
     this._sanitizePackages(packageNames);
 
-    await this.cacheDeployModules(packageNames);
+    await this._cacheDeployModules(packageNames);
 
     const packageMapEntries = await Promise.all(
       packageNames.map(async (packageName) => {
-        const deployerPackage = await this.getDeployModule(packageName);
+        const deployerPackage = await this._getDeployModule(packageName);
         return [packageName, deployerPackage];
       })
     );
@@ -143,7 +143,7 @@ export class Deployer {
     }
   }
 
-  private async getDeployModule(
+  private async _getDeployModule(
     moduleName: string
   ): Promise<{
     deployModule: DeployModule;
@@ -171,7 +171,7 @@ export class Deployer {
     };
   }
 
-  private async cacheDeployModules(modules: string[]): Promise<void> {
+  private async _cacheDeployModules(modules: string[]): Promise<void> {
     if (this._config.defaultModulesCached) {
       return;
     }

packages/cli/src/lib/infra/Infra.ts

@@ -276,7 +276,7 @@ export class Infra {
         const packageDir = dependencyFetcher.getPackageDir(m.package);
         const packagePath = m.dockerComposePath
           ? path.join(packageDir, m.dockerComposePath)
-          : this.tryResolveComposeFile(
+          : this._tryResolveComposeFile(
               packageDir,
               this._defaultModuleComposePaths
             );
@@ -353,7 +353,7 @@ export class Infra {
         isFile ? module.path : module.name
       );
       copySync(module.path, modulePath);
-      const composePath = this.tryResolveComposeFile(
+      const composePath = this._tryResolveComposeFile(
         modulePath,
         this._defaultModuleComposePaths
       );
@@ -386,7 +386,7 @@ export class Infra {
     return path.join(this._config.defaultInfraModulesPath, defaultModulePath);
   }
 
-  private tryResolveComposeFile(
+  private _tryResolveComposeFile(
     moduleDir: string,
     pathsToTry: string[],
     triedPaths: string[] = []
@@ -405,7 +405,7 @@ export class Infra {
       return pathToTry;
     }
 
-    return this.tryResolveComposeFile(moduleDir, pathsToTry.slice(1), [
+    return this._tryResolveComposeFile(moduleDir, pathsToTry.slice(1), [
       ...triedPaths,
       pathToTry,
     ]);

packages/cli/src/lib/system/file-lock.ts

@@ -16,7 +16,7 @@ export class FileLock {
         this._lockFilePath,
         "utf8"
       );
-      const isRunning: boolean = this.isRunning(parseInt(lockPid));
+      const isRunning: boolean = this._isRunning(parseInt(lockPid));
       // if process is not running and file exists, the lock is orphaned and can be destroyed
       if (!isRunning) {
         try {
@@ -53,7 +53,7 @@ export class FileLock {
   }
 
   // check if process is running
-  private isRunning(pid: number): boolean {
+  private _isRunning(pid: number): boolean {
     try {
       process.kill(pid, 0);
       return true;

packages/cli/src/lib/workflow/JobRunner.ts

@@ -9,26 +9,26 @@ import {
 } from "@polywrap/client-config-builder-js";
 
 export class JobRunner {
-  private jobOutput: Map<string, JobResult>;
-  private client: CoreClient;
+  private _jobOutput: Map<string, JobResult>;
+  private _client: CoreClient;
 
   constructor(
-    private configBuilder: IClientConfigBuilder,
-    private onExecution?: (id: string, JobResult: JobResult) => MaybeAsync<void>
+    private _configBuilder: IClientConfigBuilder,
+    private _onExecution?: (id: string, JobResult: JobResult) => MaybeAsync<void>
   ) {
-    this.jobOutput = new Map();
-    this.client = new PolywrapClient(this.configBuilder.buildCoreConfig(), {
+    this._jobOutput = new Map();
+    this._client = new PolywrapClient(this._configBuilder.buildCoreConfig(), {
       noDefaults: true,
     });
   }
 
   async run(jobs: WorkflowJobs, ids: string[]): Promise<void> {
     const running = ids.map(async (absJobId) => {
-      const jobId = this.getJobId(absJobId);
+      const jobId = this._getJobId(absJobId);
 
       const steps: Step[] | undefined = jobs[jobId].steps as Step[];
       if (steps) {
-        await this.executeSteps(absJobId, steps);
+        await this._executeSteps(absJobId, steps);
       }
 
       const subJobs: WorkflowJobs | undefined = jobs[jobId].jobs;
@@ -40,15 +40,15 @@ export class JobRunner {
     await Promise.all(running);
   }
 
-  private getJobId(absJobId: string): string {
+  private _getJobId(absJobId: string): string {
     const dotIdx = absJobId.lastIndexOf(".");
     if (dotIdx > -1) {
       return absJobId.substring(dotIdx + 1);
     }
     return absJobId;
   }
 
-  private followAccessors(
+  private _followAccessors(
     jobResult: JobResult,
     accessors: string[],
     referenceId: string,
@@ -69,7 +69,7 @@ export class JobRunner {
     return val;
   }
 
-  private resolveReference(
+  private _resolveReference(
     absJobId: string,
     stepId: number,
     reference: string
@@ -87,12 +87,12 @@ export class JobRunner {
 
     // get reference job output
     const referenceId: string = reference.substring(1, dataOrErrorIdx);
-    if (!this.jobOutput.has(referenceId)) {
+    if (!this._jobOutput.has(referenceId)) {
       throw new Error(
         `Could not resolve reference id ${referenceId} for step ${absJobId}.${stepId}`
       );
     }
-    const refJobResult = this.jobOutput.get(referenceId) as JobResult;
+    const refJobResult = this._jobOutput.get(referenceId) as JobResult;
 
     // parse and validate accessors
     const accessors: string[] = reference
@@ -119,7 +119,7 @@ export class JobRunner {
     }
 
     // follow accessors through reference output to get requested data
-    return this.followAccessors(
+    return this._followAccessors(
       refJobResult,
       accessors,
       referenceId,
@@ -128,51 +128,51 @@ export class JobRunner {
     );
   }
 
-  private resolveRecord(
+  private _resolveRecord(
     absJobId: string,
     stepId: number,
     record: Record<string, unknown>
   ): Record<string, unknown> {
     const resolved: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(record)) {
-      resolved[key] = this.resolveValue(absJobId, stepId, value);
+      resolved[key] = this._resolveValue(absJobId, stepId, value);
     }
     return resolved;
   }
 
-  private resolveArray(
+  private _resolveArray(
     absJobId: string,
     stepId: number,
     array: Array<unknown>
   ): Array<unknown> {
-    return array.map((v) => this.resolveValue(absJobId, stepId, v));
+    return array.map((v) => this._resolveValue(absJobId, stepId, v));
   }
 
-  private resolveValue(
+  private _resolveValue(
     absJobId: string,
     stepId: number,
     value: unknown
   ): unknown {
-    if (this.isReference(value)) {
-      return this.resolveReference(absJobId, stepId, value);
+    if (this._isReference(value)) {
+      return this._resolveReference(absJobId, stepId, value);
     } else if (Array.isArray(value)) {
-      return this.resolveArray(absJobId, stepId, value);
-    } else if (this.isRecord(value)) {
-      return this.resolveRecord(absJobId, stepId, value);
+      return this._resolveArray(absJobId, stepId, value);
+    } else if (this._isRecord(value)) {
+      return this._resolveRecord(absJobId, stepId, value);
     } else {
       return value;
     }
   }
 
-  private async execStep(
+  private async _execStep(
     absJobId: string,
     stepId: number,
     step: Step
   ): Promise<JobResult> {
     let args: Record<string, unknown> | undefined;
     if (step.args) {
       try {
-        args = this.resolveRecord(absJobId, stepId, step.args);
+        args = this._resolveRecord(absJobId, stepId, step.args);
       } catch (e) {
         return {
           error: e,
@@ -181,12 +181,12 @@ export class JobRunner {
       }
     }
 
-    let finalClient = this.client;
+    let finalClient = this._client;
 
     if (step.config) {
       const finalConfig = (step.config as Partial<CoreClientConfig>).resolver
         ? (step.config as CoreClientConfig)
-        : this.configBuilder
+        : this._configBuilder
             .add(step.config as Partial<ClientConfig>)
             .buildCoreConfig();
 
@@ -206,26 +206,26 @@ export class JobRunner {
     }
   }
 
-  private async executeSteps(absJobId: string, steps: Step[]) {
+  private async _executeSteps(absJobId: string, steps: Step[]) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
       const absId = `${absJobId}.${i}`;
 
-      const result: JobResult = await this.execStep(absJobId, i, step);
+      const result: JobResult = await this._execStep(absJobId, i, step);
 
-      this.jobOutput.set(absId, result);
+      this._jobOutput.set(absId, result);
 
-      if (this.onExecution) {
-        await this.onExecution(absId, result);
+      if (this._onExecution) {
+        await this._onExecution(absId, result);
       }
     }
   }
 
-  private isReference(value: unknown): value is string {
+  private _isReference(value: unknown): value is string {
     return typeof value === "string" && value.startsWith("$");
   }
 
-  private isRecord(value: unknown): value is Record<string, unknown> {
+  private _isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === "object" && value !== null;
   }
 }

packages/js/client-config-builder/src/ClientConfigBuilder.ts

@@ -13,8 +13,8 @@ import { ExtendableUriResolver } from "@polywrap/uri-resolver-extensions-js";
 
 export class ClientConfigBuilder extends BaseClientConfigBuilder {
   constructor(
-    private readonly wrapperCache?: IWrapperCache,
-    private readonly resolver?: IUriResolver<unknown>
+    private readonly _wrapperCache?: IWrapperCache,
+    private readonly _resolver?: IUriResolver<unknown>
   ) {
     super();
   }
@@ -28,7 +28,7 @@ export class ClientConfigBuilder extends BaseClientConfigBuilder {
       envs: this.config.envs,
       interfaces: this.config.interfaces,
       resolver:
-        this.resolver ??
+        this._resolver ??
         RecursiveResolver.from(
           PackageToWrapperCacheResolver.from(
             [
@@ -40,7 +40,7 @@ export class ClientConfigBuilder extends BaseClientConfigBuilder {
               ...this.config.resolvers,
               new ExtendableUriResolver(),
             ],
-            this.wrapperCache ?? new WrapperCache()
+            this._wrapperCache ?? new WrapperCache()
           )
         ),
     };

packages/js/core-client/src/PolywrapCoreClient.ts

@@ -47,7 +47,7 @@ export class PolywrapCoreClient implements CoreClient {
 
       Tracer.startSpan("PolywrapClient: constructor");
 
-      this._config = this.buildConfigFromPolywrapCoreClientConfig(config);
+      this._config = this._buildConfigFromPolywrapCoreClientConfig(config);
 
       Tracer.setAttribute("config", this._config);
     } catch (error) {
@@ -581,7 +581,7 @@ export class PolywrapCoreClient implements CoreClient {
     return ResultOk(true);
   }
 
-  private buildConfigFromPolywrapCoreClientConfig(
+  private _buildConfigFromPolywrapCoreClientConfig(
     config: PolywrapCoreClientConfig
   ): PolywrapCoreClientConfig<Uri> {
     return {