chore: Refactor for simpler application root

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>
Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

packages/infrastructure/lens-link/src/config-file-path.injectable.ts

@@ -0,0 +1,16 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { resolvePathInjectable } from "./path/resolve-path.injectable";
+import { workingDirectoryInjectable } from "./working-directory.injectable";
+
+const configFilePathInjectable = getInjectable({
+  id: "config-file-path",
+
+  instantiate: (di) => {
+    const resolvePath = di.inject(resolvePathInjectable);
+    const workingDirectory = di.inject(workingDirectoryInjectable);
+
+    return resolvePath(workingDirectory, ".lens-links.json");
+  },
+});
+
+export default configFilePathInjectable;

packages/infrastructure/lens-link/src/create-empty-config.injectable.ts

@@ -0,0 +1,18 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { writeJsonFileInjectable } from "./fs/write-json-file.injectable";
+import configFilePathInjectable from "./config-file-path.injectable";
+
+const createEmptyConfigInjectable = getInjectable({
+  id: "create-empty-config",
+
+  instantiate: (di) => {
+    const configFilePath = di.inject(configFilePathInjectable);
+    const writeJsonFile = di.inject(writeJsonFileInjectable);
+
+    return async () => {
+      await writeJsonFile(configFilePath, []);
+    };
+  },
+});
+
+export default createEmptyConfigInjectable;

packages/infrastructure/lens-link/src/create-symlinks.injectable.ts

@@ -3,16 +3,20 @@ import { awaitAll } from "./await-all";
 import { getInjectable } from "@ogre-tools/injectable";
 import { pipeline } from "@ogre-tools/fp";
 import { createSymlinkInjectable } from "./fs/create-symlink.injectable";
+import type { PackageJsonAndPath } from "./package-json-and-path";
+import { getSymlinkPathsInjectable } from "./get-symlink-paths.injectable";
 
-export const createSymLinksInjectable = getInjectable({
-  id: "create-sym-links",
+export const createSymlinksInjectable = getInjectable({
+  id: "create-symlinks",
 
   instantiate: (di) => {
+    const getSymlinkPaths = di.inject(getSymlinkPathsInjectable);
     const createSymlink = di.inject(createSymlinkInjectable);
 
-    return async (symlinkPaths: { target: string; source: string; type: "file" | "dir" }[]) => {
+    return async (packageJsons: PackageJsonAndPath[]) => {
       await pipeline(
-        symlinkPaths,
+        packageJsons,
+        getSymlinkPaths,
         map(({ target, source, type }) => createSymlink(target, source, type)),
         awaitAll,
       );

packages/infrastructure/lens-link/src/get-config.injectable.ts

@@ -0,0 +1,28 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { existsInjectable } from "./fs/exists.injectable";
+import { readJsonFileInjectable } from "./fs/read-json-file.injectable";
+import configFilePathInjectable from "./config-file-path.injectable";
+
+export type Config = string[];
+
+const getConfigInjectable = getInjectable({
+  id: "get-config",
+
+  instantiate: (di) => {
+    const exists = di.inject(existsInjectable);
+    const readJsonFile = di.inject(readJsonFileInjectable);
+    const configFilePath = di.inject(configFilePathInjectable);
+
+    return async () => {
+      const configFileExists = await exists(configFilePath);
+
+      if (!configFileExists) {
+        return;
+      }
+
+      return readJsonFile(configFilePath) as unknown as Config;
+    };
+  },
+});
+
+export default getConfigInjectable;

packages/infrastructure/lens-link/src/get-package-json-paths.injectable.ts

@@ -1,20 +1,16 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { resolvePathInjectable } from "./path/resolve-path.injectable";
 import { workingDirectoryInjectable } from "./working-directory.injectable";
-import { readJsonFileInjectable } from "./fs/read-json-file.injectable";
+import type { Config } from "./get-config.injectable";
 
 export const getPackageJsonPathsInjectable = getInjectable({
   id: "get-package-json-paths",
 
   instantiate: (di) => {
-    const readJsonFile = di.inject(readJsonFileInjectable);
     const resolvePath = di.inject(resolvePathInjectable);
     const workingDirectory = di.inject(workingDirectoryInjectable);
 
-    return async (configFilePath: string) => {
-      const configFile = (await readJsonFile(configFilePath)) as string[];
-
-      return configFile.map((linkPath: string) => resolvePath(workingDirectory, linkPath, "package.json"));
-    };
+    return (config: Config) =>
+      config.map((linkPath: string) => resolvePath(workingDirectory, linkPath, "package.json"));
   },
 });

packages/infrastructure/lens-link/src/get-package-jsons.injectable.ts

@@ -4,15 +4,24 @@ import { map } from "lodash/fp";
 import type { PackageJson } from "./package-json-and-path";
 import { getInjectable } from "@ogre-tools/injectable";
 import { readJsonFileInjectable } from "./fs/read-json-file.injectable";
+import { getPackageJsonPathsInjectable } from "./get-package-json-paths.injectable";
+import { checkForMissingPackageJsonsInjectable } from "./check-for-missing-package-jsons.injectable";
+import type { Config } from "./get-config.injectable";
 
 export const getPackageJsonsInjectable = getInjectable({
   id: "get-package-jsons",
 
   instantiate: (di) => {
     const readJsonFile = di.inject(readJsonFileInjectable);
+    const getPackageJsonPaths = di.inject(getPackageJsonPathsInjectable);
+    const checkForMissingPackageJsons = di.inject(checkForMissingPackageJsonsInjectable);
 
-    return async (packageJsonPaths: string[]) =>
-      pipeline(
+    return async (config: Config) => {
+      const packageJsonPaths = await getPackageJsonPaths(config);
+
+      await checkForMissingPackageJsons(packageJsonPaths);
+
+      return pipeline(
         packageJsonPaths,
 
         map(async (packageJsonPath) => ({
@@ -22,5 +31,6 @@ export const getPackageJsonsInjectable = getInjectable({
 
         awaitAll,
       );
+    };
   },
 });

packages/infrastructure/lens-link/src/lens-link.injectable.ts

@@ -1,15 +1,10 @@
 import { removeExistingLensLinkDirectoriesInjectable } from "./remove-existing-lens-link-directories.injectable";
 import { createLensLinkDirectoriesInjectable } from "./create-lens-link-directories.injectable";
 import { getPackageJsonsInjectable } from "./get-package-jsons.injectable";
-import { getPackageJsonPathsInjectable } from "./get-package-json-paths.injectable";
 import { getInjectable } from "@ogre-tools/injectable";
-import { resolvePathInjectable } from "./path/resolve-path.injectable";
-import { existsInjectable } from "./fs/exists.injectable";
-import { writeJsonFileInjectable } from "./fs/write-json-file.injectable";
-import { workingDirectoryInjectable } from "./working-directory.injectable";
-import { getSymlinkPathsInjectable } from "./get-symlink-paths.injectable";
-import { createSymLinksInjectable } from "./create-sym-links.injectable";
-import { checkForMissingPackageJsonsInjectable } from "./check-for-missing-package-jsons.injectable";
+import { createSymlinksInjectable } from "./create-symlinks.injectable";
+import getConfigInjectable from "./get-config.injectable";
+import createEmptyConfigInjectable from "./create-empty-config.injectable";
 
 export type LensLink = () => Promise<void>;
 
@@ -20,39 +15,24 @@ const lensLinkInjectable = getInjectable({
     const getPackageJsons = di.inject(getPackageJsonsInjectable);
     const removeExistingLensLinkDirectories = di.inject(removeExistingLensLinkDirectoriesInjectable);
     const createLensLinkDirectories = di.inject(createLensLinkDirectoriesInjectable);
-    const getPackageJsonPaths = di.inject(getPackageJsonPathsInjectable);
-    const resolvePath = di.inject(resolvePathInjectable);
-    const exists = di.inject(existsInjectable);
-    const writeJsonFile = di.inject(writeJsonFileInjectable);
-    const workingDirectory = di.inject(workingDirectoryInjectable);
-    const getSymlinkPaths = di.inject(getSymlinkPathsInjectable);
-    const createSymLinks = di.inject(createSymLinksInjectable);
-    const checkForMissingPackageJsons = di.inject(checkForMissingPackageJsonsInjectable);
+    const createSymlinks = di.inject(createSymlinksInjectable);
+    const getConfig = di.inject(getConfigInjectable);
+    const createEmptyConfig = di.inject(createEmptyConfigInjectable);
 
     return async () => {
-      const configFilePath = resolvePath(workingDirectory, ".lens-links.json");
+      const config = await getConfig();
 
-      const configFileExists = await exists(configFilePath);
-
-      if (!configFileExists) {
-        await writeJsonFile(configFilePath, []);
+      if (!config) {
+        await createEmptyConfig();
 
         return;
       }
 
-      const packageJsonPaths = await getPackageJsonPaths(configFilePath);
-
-      await checkForMissingPackageJsons(packageJsonPaths);
-
-      const packageJsons = await getPackageJsons(packageJsonPaths);
+      const packageJsons = await getPackageJsons(config);
 
       await removeExistingLensLinkDirectories(packageJsons);
-
       await createLensLinkDirectories(packageJsons);
-
-      const symlinkPaths = await getSymlinkPaths(packageJsons);
-
-      await createSymLinks(symlinkPaths);
+      await createSymlinks(packageJsons);
     };
   },
 });