refactor(cli): organize files, simplify types, use @immich/sdk (#6747)

cli/src/services/api.service.ts

@@ -0,0 +1,57 @@
+import {
+  AlbumApi,
+  APIKeyApi,
+  AssetApi,
+  AuthenticationApi,
+  Configuration,
+  JobApi,
+  OAuthApi,
+  ServerInfoApi,
+  SystemConfigApi,
+  UserApi,
+} from '@immich/sdk';
+import FormData from 'form-data';
+
+export class ImmichApi {
+  public userApi: UserApi;
+  public albumApi: AlbumApi;
+  public assetApi: AssetApi;
+  public authenticationApi: AuthenticationApi;
+  public oauthApi: OAuthApi;
+  public serverInfoApi: ServerInfoApi;
+  public jobApi: JobApi;
+  public keyApi: APIKeyApi;
+  public systemConfigApi: SystemConfigApi;
+
+  private readonly config;
+
+  constructor(
+    public instanceUrl: string,
+    public apiKey: string,
+  ) {
+    this.config = new Configuration({
+      basePath: instanceUrl,
+      baseOptions: {
+        headers: {
+          'x-api-key': apiKey,
+        },
+      },
+      formDataCtor: FormData,
+    });
+
+    this.userApi = new UserApi(this.config);
+    this.albumApi = new AlbumApi(this.config);
+    this.assetApi = new AssetApi(this.config);
+    this.authenticationApi = new AuthenticationApi(this.config);
+    this.oauthApi = new OAuthApi(this.config);
+    this.serverInfoApi = new ServerInfoApi(this.config);
+    this.jobApi = new JobApi(this.config);
+    this.keyApi = new APIKeyApi(this.config);
+    this.systemConfigApi = new SystemConfigApi(this.config);
+  }
+
+  setApiKey(apiKey: string) {
+    this.apiKey = apiKey;
+    this.config.baseOptions.headers['x-api-key'] = apiKey;
+  }
+}

cli/src/services/crawl.service.spec.ts

@@ -1,10 +1,9 @@
 import mockfs from 'mock-fs';
-import { CrawlOptionsDto } from 'src/cores/dto/crawl-options-dto';
-import { CrawlService } from '.';
+import { CrawlService, CrawlOptions } from './crawl.service';
 
 interface Test {
   test: string;
-  options: CrawlOptionsDto;
+  options: CrawlOptions;
   files: Record<string, boolean>;
 }
 

cli/src/services/crawl.service.ts

@@ -1,7 +1,13 @@
-import { CrawlOptionsDto } from 'src/cores/dto/crawl-options-dto';
 import { glob } from 'glob';
 import * as fs from 'fs';
 
+export class CrawlOptions {
+  pathsToCrawl!: string[];
+  recursive? = false;
+  includeHidden? = false;
+  exclusionPatterns?: string[];
+}
+
 export class CrawlService {
   private readonly extensions!: string[];
 
@@ -9,8 +15,9 @@ export class CrawlService {
     this.extensions = image.concat(video).map((extension) => extension.replace('.', ''));
   }
 
-  async crawl(crawlOptions: CrawlOptionsDto): Promise<string[]> {
-    const { pathsToCrawl, exclusionPatterns, includeHidden } = crawlOptions;
+  async crawl(options: CrawlOptions): Promise<string[]> {
+    const { recursive, pathsToCrawl, exclusionPatterns, includeHidden } = options;
+
     if (!pathsToCrawl) {
       return Promise.resolve([]);
     }
@@ -44,7 +51,7 @@ export class CrawlService {
       searchPattern = '{' + patterns.join(',') + '}';
     }
 
-    if (crawlOptions.recursive) {
+    if (recursive) {
       searchPattern = searchPattern + '/**/';
     }
 

cli/src/services/index.ts

@@ -1 +0,0 @@
-export * from './crawl.service';

cli/src/services/session.service.spec.ts

@@ -1,7 +1,6 @@
 import { SessionService } from './session.service';
 import fs from 'node:fs';
 import yaml from 'yaml';
-import { LoginError } from '../cores/errors/login-error';
 import {
   TEST_AUTH_FILE,
   TEST_CONFIG_DIR,
@@ -70,7 +69,6 @@ describe('SessionService', () => {
       }),
     );
     await sessionService.connect().catch((error) => {
-      expect(error).toBeInstanceOf(LoginError);
       expect(error.message).toEqual(`Instance URL missing in auth config file ${TEST_AUTH_FILE}`);
     });
   });
@@ -82,13 +80,11 @@ describe('SessionService', () => {
       }),
     );
 
-    await expect(sessionService.connect()).rejects.toThrow(
-      new LoginError(`API key missing in auth config file ${TEST_AUTH_FILE}`),
-    );
+    await expect(sessionService.connect()).rejects.toThrow(`API key missing in auth config file ${TEST_AUTH_FILE}`);
   });
 
   it('should create auth file when logged in', async () => {
-    await sessionService.keyLogin(TEST_IMMICH_INSTANCE_URL, TEST_IMMICH_API_KEY);
+    await sessionService.login(TEST_IMMICH_INSTANCE_URL, TEST_IMMICH_API_KEY);
 
     const data: string = await readTestAuthFile();
     const authConfig = yaml.parse(data);
@@ -109,6 +105,10 @@ describe('SessionService', () => {
       expect(error.message).toContain('ENOENT');
     });
 
-    expect(consoleSpy.mock.calls).toEqual([[`Removed auth file ${TEST_AUTH_FILE}`]]);
+    expect(consoleSpy.mock.calls).toEqual([
+      ['Logging out...'],
+      [`Removed auth file ${TEST_AUTH_FILE}`],
+      ['Successfully logged out'],
+    ]);
   });
 });

cli/src/services/session.service.ts

@@ -1,31 +1,40 @@
-import fs from 'node:fs';
-import yaml from 'yaml';
+import { existsSync } from 'fs';
+import { access, constants, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { ImmichApi } from '../api/client';
-import { LoginError } from '../cores/errors/login-error';
+import yaml from 'yaml';
+import { ImmichApi } from './api.service';
+
+class LoginError extends Error {
+  constructor(message: string) {
+    super(message);
+
+    this.name = this.constructor.name;
+
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
 
 export class SessionService {
   readonly configDir!: string;
   readonly authPath!: string;
-  private api!: ImmichApi;
 
   constructor(configDir: string) {
     this.configDir = configDir;
     this.authPath = path.join(configDir, '/auth.yml');
   }
 
-  public async connect(): Promise<ImmichApi> {
+  async connect(): Promise<ImmichApi> {
     let instanceUrl = process.env.IMMICH_INSTANCE_URL;
     let apiKey = process.env.IMMICH_API_KEY;
 
     if (!instanceUrl || !apiKey) {
-      await fs.promises.access(this.authPath, fs.constants.F_OK).catch((error) => {
+      await access(this.authPath, constants.F_OK).catch((error) => {
         if (error.code === 'ENOENT') {
           throw new LoginError('No auth file exist. Please login first');
         }
       });
 
-      const data: string = await fs.promises.readFile(this.authPath, 'utf8');
+      const data: string = await readFile(this.authPath, 'utf8');
       const parsedConfig = yaml.parse(data);
 
       instanceUrl = parsedConfig.instanceUrl;
@@ -40,51 +49,54 @@ export class SessionService {
       }
     }
 
-    this.api = new ImmichApi(instanceUrl, apiKey);
+    const api = new ImmichApi(instanceUrl, apiKey);
 
-    await this.ping();
+    const { data: pingResponse } = await api.serverInfoApi.pingServer().catch((error) => {
+      throw new Error(`Failed to connect to server ${api.instanceUrl}: ${error.message}`);
+    });
 
-    return this.api;
+    if (pingResponse.res !== 'pong') {
+      throw new Error(`Could not parse response. Is Immich listening on ${api.instanceUrl}?`);
+    }
+
+    return api;
   }
 
-  public async keyLogin(instanceUrl: string, apiKey: string): Promise<ImmichApi> {
-    this.api = new ImmichApi(instanceUrl, apiKey);
+  async login(instanceUrl: string, apiKey: string): Promise<ImmichApi> {
+    console.log('Logging in...');
+
+    const api = new ImmichApi(instanceUrl, apiKey);
 
     // Check if server and api key are valid
-    const { data: userInfo } = await this.api.userApi.getMyUserInfo().catch((error) => {
+    const { data: userInfo } = await api.userApi.getMyUserInfo().catch((error) => {
       throw new LoginError(`Failed to connect to server ${instanceUrl}: ${error.message}`);
     });
 
     console.log(`Logged in as ${userInfo.email}`);
 
-    if (!fs.existsSync(this.configDir)) {
+    if (!existsSync(this.configDir)) {
       // Create config folder if it doesn't exist
-      const created = await fs.promises.mkdir(this.configDir, { recursive: true });
+      const created = await mkdir(this.configDir, { recursive: true });
       if (!created) {
         throw new Error(`Failed to create config folder ${this.configDir}`);
       }
     }
 
-    fs.writeFileSync(this.authPath, yaml.stringify({ instanceUrl, apiKey }));
+    await writeFile(this.authPath, yaml.stringify({ instanceUrl, apiKey }));
 
     console.log('Wrote auth info to ' + this.authPath);
-    return this.api;
+
+    return api;
   }
 
-  public async logout(): Promise<void> {
-    if (fs.existsSync(this.authPath)) {
-      fs.unlinkSync(this.authPath);
+  async logout(): Promise<void> {
+    console.log('Logging out...');
+
+    if (existsSync(this.authPath)) {
+      await unlink(this.authPath);
       console.log('Removed auth file ' + this.authPath);
     }
-  }
 
-  private async ping(): Promise<void> {
-    const { data: pingResponse } = await this.api.serverInfoApi.pingServer().catch((error) => {
-      throw new Error(`Failed to connect to server ${this.api.apiConfiguration.instanceUrl}: ${error.message}`);
-    });
-
-    if (pingResponse.res !== 'pong') {
-      throw new Error(`Could not parse response. Is Immich listening on ${this.api.apiConfiguration.instanceUrl}?`);
-    }
+    console.log('Successfully logged out');
   }
 }