Consolidate to use injectable instead of var for static file directory

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/common/vars.ts

@@ -123,12 +123,6 @@ export const kubectlBinaryName = getBinaryName("kubectl");
  * @deprecated for being explicit side effect.
  */
 export const kubectlBinaryPath = lazyInitialized(() => path.join(baseBinariesDir.get(), kubectlBinaryName));
-export const staticFilesDirectory = path.resolve(
-  !isProduction
-    ? process.cwd()
-    : process.resourcesPath,
-  "static",
-);
 
 // Apis
 export const apiPrefix = "/api" as string; // local router apis

src/common/vars/static-files-directory.injectable.ts

@@ -6,8 +6,8 @@ import { getInjectable } from "@ogre-tools/injectable";
 import getAbsolutePathInjectable from "../path/get-absolute-path.injectable";
 import lensResourcesDirInjectable from "./lens-resources-dir.injectable";
 
-const staticDirInjectable = getInjectable({
-  id: "static-dir",
+const staticFilesDirectoryInjectable = getInjectable({
+  id: "static-files-directory",
 
   instantiate: (di) => {
     const getAbsolutePath = di.inject(getAbsolutePathInjectable);
@@ -17,4 +17,4 @@ const staticDirInjectable = getInjectable({
   },
 });
 
-export default staticDirInjectable;
+export default staticFilesDirectoryInjectable;

src/extensions/extension-discovery/extension-discovery.injectable.ts

@@ -12,6 +12,7 @@ import extensionInstallationStateStoreInjectable from "../extension-installation
 import installExtensionInjectable from "../extension-installer/install-extension/install-extension.injectable";
 import extensionPackageRootDirectoryInjectable from "../extension-installer/extension-package-root-directory/extension-package-root-directory.injectable";
 import installExtensionsInjectable from "../extension-installer/install-extensions/install-extensions.injectable";
+import staticFilesDirectoryInjectable from "../../common/vars/static-files-directory.injectable";
 
 const extensionDiscoveryInjectable = getInjectable({
   id: "extension-discovery",
@@ -37,6 +38,8 @@ const extensionDiscoveryInjectable = getInjectable({
       extensionPackageRootDirectory: di.inject(
         extensionPackageRootDirectoryInjectable,
       ),
+
+      staticFilesDirectory: di.inject(staticFilesDirectoryInjectable),
     }),
 });
 

src/extensions/extension-discovery/extension-discovery.ts

@@ -16,7 +16,7 @@ import logger from "../../main/logger";
 import type { ExtensionsStore } from "../extensions-store/extensions-store";
 import type { ExtensionLoader } from "../extension-loader";
 import type { LensExtensionId, LensExtensionManifest } from "../lens-extension";
-import { isProduction, staticFilesDirectory } from "../../common/vars";
+import { isProduction } from "../../common/vars";
 import type { ExtensionInstallationStateStore } from "../extension-installation-state-store/extension-installation-state-store";
 import type { PackageJson } from "type-fest";
 import { extensionDiscoveryStateChannel } from "../../common/ipc/extension-handling";
@@ -34,6 +34,7 @@ interface Dependencies {
   installExtension: (name: string) => Promise<void>;
   installExtensions: (packageJsonPath: string, packagesJson: PackageJson) => Promise<void>;
   extensionPackageRootDirectory: string;
+  staticFilesDirectory: string;
 }
 
 export interface InstalledExtension {
@@ -112,7 +113,7 @@ export class ExtensionDiscovery {
   }
 
   get inTreeFolderPath(): string {
-    return path.resolve(staticFilesDirectory, "../extensions");
+    return path.resolve(this.dependencies.staticFilesDirectory, "../extensions");
   }
 
   get nodeModulesPath(): string {

src/main/routes/static-file-route.injectable.ts

@@ -8,7 +8,7 @@ import type { SupportedFileExtension } from "../router/router-content-types";
 import { contentTypes } from "../router/router-content-types";
 import logger from "../logger";
 import { routeInjectionToken } from "../router/router.injectable";
-import { appName, publicPath, staticFilesDirectory } from "../../common/vars";
+import { appName, publicPath } from "../../common/vars";
 import path from "path";
 import isDevelopmentInjectable from "../../common/vars/is-development.injectable";
 import httpProxy from "http-proxy";
@@ -18,24 +18,25 @@ import getAbsolutePathInjectable from "../../common/path/get-absolute-path.injec
 import type { JoinPaths } from "../../common/path/join-paths.injectable";
 import joinPathsInjectable from "../../common/path/join-paths.injectable";
 import { webpackDevServerPort } from "../../../webpack/vars";
+import staticFilesDirectoryInjectable from "../../common/vars/static-files-directory.injectable";
 
 interface ProductionDependencies {
   readFileBuffer: (path: string) => Promise<Buffer>;
   getAbsolutePath: GetAbsolutePath;
   joinPaths: JoinPaths;
+  staticFilesDirectory: string;
 }
 
 const handleStaticFileInProduction =
-  ({ readFileBuffer, getAbsolutePath, joinPaths }: ProductionDependencies) =>
+  ({ readFileBuffer, getAbsolutePath, joinPaths, staticFilesDirectory }: ProductionDependencies) =>
     async ({ params }: LensApiRequest) => {
-      const staticPath = getAbsolutePath(staticFilesDirectory);
       let filePath = params.path;
 
       for (let retryCount = 0; retryCount < 5; retryCount += 1) {
-        const asset = joinPaths(staticPath, filePath);
+        const asset = joinPaths(staticFilesDirectory, filePath);
         const normalizedFilePath = getAbsolutePath(asset);
 
-        if (!normalizedFilePath.startsWith(staticPath)) {
+        if (!normalizedFilePath.startsWith(staticFilesDirectory)) {
           return { statusCode: 404 };
         }
 
@@ -89,13 +90,14 @@ const staticFileRouteInjectable = getInjectable({
     const readFileBuffer = di.inject(readFileBufferInjectable);
     const getAbsolutePath = di.inject(getAbsolutePathInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
+    const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
 
     return {
       method: "get",
       path: `/{path*}`,
       handler: isDevelopment
         ? handleStaticFileInDevelopment({ proxy: httpProxy.createProxy() })
-        : handleStaticFileInProduction({ readFileBuffer, getAbsolutePath, joinPaths }),
+        : handleStaticFileInProduction({ readFileBuffer, getAbsolutePath, joinPaths, staticFilesDirectory }),
     };
   },
 

src/main/start-main-application/after-application-is-ready/implementations/setup-file-protocol.injectable.ts

@@ -5,19 +5,18 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";
 import registerFileProtocolInjectable from "../../../electron-app/features/register-file-protocol.injectable";
-
-import staticDirInjectable from "../../../../common/vars/static-dir.injectable";
+import staticFilesDirectoryInjectable from "../../../../common/vars/static-files-directory.injectable";
 
 const setupFileProtocolInjectable = getInjectable({
   id: "setup-file-protocol",
 
   instantiate: (di) => {
     const registerFileProtocol = di.inject(registerFileProtocolInjectable);
-    const staticDir = di.inject(staticDirInjectable);
+    const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
 
     return {
       run: () => {
-        registerFileProtocol("static", staticDir);
+        registerFileProtocol("static", staticFilesDirectory);
       },
     };
   },

src/renderer/components/dock/create-resource/lens-templates.injectable.ts

@@ -5,20 +5,21 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import path from "path";
 import { hasCorrectExtension } from "./has-correct-extension";
-import { staticFilesDirectory } from "../../../../common/vars";
 import readFileInjectable from "../../../../common/fs/read-file.injectable";
 import readDirInjectable from "../../../../common/fs/read-dir.injectable";
 import type { RawTemplates } from "./create-resource-templates.injectable";
 import type { GetAbsolutePath } from "../../../../common/path/get-absolute-path.injectable";
 import getAbsolutePathInjectable from "../../../../common/path/get-absolute-path.injectable";
+import staticFilesDirectoryInjectable from "../../../../common/vars/static-files-directory.injectable";
 
 interface Dependencies {
   readDir: (dirPath: string) => Promise<string[]>;
   readFile: (filePath: string) => Promise<string>;
   getAbsolutePath: GetAbsolutePath;
+  staticFilesDirectory: string;
 }
 
-async function getTemplates({ readDir, readFile, getAbsolutePath }: Dependencies) {
+async function getTemplates({ readDir, readFile, getAbsolutePath, staticFilesDirectory }: Dependencies) {
   const templatesFolder = getAbsolutePath(staticFilesDirectory, "../templates/create-resource");
 
   /**
@@ -43,6 +44,7 @@ const lensCreateResourceTemplatesInjectable = getInjectable({
       readFile: di.inject(readFileInjectable),
       readDir: di.inject(readDirInjectable),
       getAbsolutePath: di.inject(getAbsolutePathInjectable),
+      staticFilesDirectory: di.inject(staticFilesDirectoryInjectable),
     });
 
     return ["lens", templates];