github-issue-tower-defence-management 1.1.0

package/src/domain/usecases/HandleScheduledEventUseCase.test.ts

@@ -0,0 +1,58 @@
+import { HandleScheduledEventUseCase } from './HandleScheduledEventUseCase';
+
+describe('HandleScheduledEventUseCase', () => {
+  describe('createTargetDateTimes', () => {
+    const testCases: {
+      lastExecutionDateTime: Date;
+      now: Date;
+      expected: Date[];
+    }[] = [
+      {
+        lastExecutionDateTime: new Date('2021-01-01T00:00:00Z'),
+        now: new Date('2021-01-01T00:00:00Z'),
+        expected: [],
+      },
+      {
+        lastExecutionDateTime: new Date('2021-01-01T00:00:00Z'),
+        now: new Date('2021-01-01T00:00:01Z'),
+        expected: [],
+      },
+      {
+        lastExecutionDateTime: new Date('2021-01-01T00:00:00Z'),
+        now: new Date('2020-01-01T00:00:02Z'),
+        expected: [new Date('2020-01-01T00:00:00Z')],
+      },
+      {
+        lastExecutionDateTime: new Date('2021-01-01T00:00:00Z'),
+        now: new Date('2021-01-01T00:05:00Z'),
+        expected: [
+          new Date('2021-01-01T00:01:00Z'),
+          new Date('2021-01-01T00:02:00Z'),
+          new Date('2021-01-01T00:03:00Z'),
+          new Date('2021-01-01T00:04:00Z'),
+          new Date('2021-01-01T00:05:00Z'),
+        ],
+      },
+      {
+        lastExecutionDateTime: new Date('2021-01-01T00:00:00Z'),
+        now: new Date('2022-01-01T00:00:00Z'),
+        expected: Array(30)
+          .fill(0)
+          .map((_, i) => {
+            const d = new Date('2021-01-01T00:00:00Z');
+            d.setTime(d.getTime() + (i + 1) * 60 * 1000);
+            return d;
+          }),
+      },
+    ];
+    testCases.forEach((testCase) => {
+      it(`should return ${testCase.expected.map((d) => d.toISOString()).join(',')} when lastExecutionDateTime is ${testCase.lastExecutionDateTime.toISOString()} and now is ${testCase.now.toISOString()}`, () => {
+        const result = HandleScheduledEventUseCase.createTargetDateTimes(
+          testCase.lastExecutionDateTime,
+          testCase.now,
+        );
+        expect(result).toEqual(testCase.expected);
+      });
+    });
+  });
+});

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -0,0 +1,209 @@
+import { Issue, Label } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { GenerateWorkingTimeReportUseCase } from './GenerateWorkingTimeReportUseCase';
+import { Member } from '../entities/Member';
+import { DateRepository } from './adapter-interfaces/DateRepository';
+import { SpreadsheetRepository } from './adapter-interfaces/SpreadsheetRepository';
+import { ActionAnnouncementUseCase } from './ActionAnnouncementUseCase';
+import { SetWorkflowManagementIssueToStoryUseCase } from './SetWorkflowManagementIssueToStoryUseCase';
+import { ClearNextActionHourUseCase } from './ClearNextActionHourUseCase';
+import { AnalyzeProblemByIssueUseCase } from './AnalyzeProblemByIssueUseCase';
+
+export class ProjectNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ProjectNotFoundError';
+  }
+}
+
+export class HandleScheduledEventUseCase {
+  constructor(
+    readonly generateWorkingTimeReportUseCase: GenerateWorkingTimeReportUseCase,
+    readonly actionAnnouncementUseCase: ActionAnnouncementUseCase,
+    readonly setWorkflowManagementIssueToStoryUseCase: SetWorkflowManagementIssueToStoryUseCase,
+    readonly clearNextActionHourUseCase: ClearNextActionHourUseCase,
+    readonly analyzeProblemByIssueUseCase: AnalyzeProblemByIssueUseCase,
+    readonly dateRepository: DateRepository,
+    readonly spreadsheetRepository: SpreadsheetRepository,
+    readonly projectRepository: ProjectRepository,
+    readonly issueRepository: IssueRepository,
+  ) {}
+
+  run = async (input: {
+    org: string;
+    projectUrl: string;
+    manager: Member['name'];
+    workingReport: {
+      repo: string;
+      members: Member['name'][];
+      warningThresholdHour?: number;
+      spreadsheetUrl: string;
+      reportIssueTemplate?: string;
+      reportIssueLabels: Label[];
+    };
+  }): Promise<{
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    targetDateTimes: Date[];
+  }> => {
+    const projectId = await this.projectRepository.findProjectIdByUrl(
+      input.projectUrl,
+    );
+    if (!projectId) {
+      throw new ProjectNotFoundError(
+        `Project not found. projectUrl: ${input.projectUrl}`,
+      );
+    }
+    const project = await this.projectRepository.getProject(projectId);
+    if (!project) {
+      throw new ProjectNotFoundError(
+        `Project not found. projectId: ${
+          projectId
+        } projectUrl: ${input.projectUrl}`,
+      );
+    }
+    const now: Date = await this.dateRepository.now();
+    const allowIssueCacheMinutes = 60;
+    const { issues, cacheUsed }: { issues: Issue[]; cacheUsed: boolean } =
+      await this.issueRepository.getAllIssues(
+        projectId,
+        allowIssueCacheMinutes,
+      );
+
+    const targetDateTimes: Date[] =
+      await this.findTargetDateAndUpdateLastExecutionDateTime(
+        input.workingReport.spreadsheetUrl,
+        now,
+      );
+
+    for (const targetDateTime of targetDateTimes) {
+      await this.runForTargetDateTime({
+        org: input.org,
+        manager: input.manager,
+        workingReport: input.workingReport,
+        projectId,
+        issues,
+        targetDateTime,
+      });
+    }
+    await this.analyzeProblemByIssueUseCase.run({
+      targetDates: targetDateTimes,
+      project,
+      issues,
+      cacheUsed,
+      manager: input.manager,
+      org: input.org,
+      repo: input.workingReport.repo,
+    });
+    await this.actionAnnouncementUseCase.run({
+      targetDates: targetDateTimes,
+      project,
+      issues,
+      cacheUsed,
+      members: input.workingReport.members,
+      manager: input.manager,
+    });
+    await this.setWorkflowManagementIssueToStoryUseCase.run({
+      targetDates: targetDateTimes,
+      project,
+      issues,
+      cacheUsed,
+    });
+    await this.clearNextActionHourUseCase.run({
+      targetDates: targetDateTimes,
+      project,
+      issues,
+      cacheUsed,
+    });
+    return { project, issues, cacheUsed, targetDateTimes };
+  };
+  runForTargetDateTime = async (input: {
+    org: string;
+    manager: Member['name'];
+    workingReport: {
+      repo: string;
+      members: Member['name'][];
+      warningThresholdHour?: number;
+      spreadsheetUrl: string;
+      reportIssueTemplate?: string;
+      reportIssueLabels: Label[];
+    };
+    projectId: Project['id'];
+    issues: Issue[];
+    targetDateTime: Date;
+  }): Promise<void> => {
+    const targetHour = input.targetDateTime.getHours();
+    const targetMinute = input.targetDateTime.getMinutes();
+    if (targetHour === 0 && targetMinute === 0) {
+      const yesterday = new Date(
+        input.targetDateTime.getTime() - 24 * 60 * 60 * 1000,
+      );
+
+      await this.generateWorkingTimeReportUseCase.run({
+        ...input,
+        ...input.workingReport,
+        targetDate: yesterday,
+      });
+    }
+  };
+  static createTargetDateTimes = (from: Date, to: Date): Date[] => {
+    const targetDateTimes: Date[] = [];
+    if (from.getTime() > to.getTime()) {
+      const targetDate = new Date(to);
+      targetDate.setSeconds(0);
+      targetDate.setMilliseconds(0);
+      return [targetDate];
+    }
+    const targetDate = new Date(from);
+    targetDate.setTime(targetDate.getTime() + 60 * 1000);
+    targetDate.setSeconds(0);
+    targetDate.setMilliseconds(0);
+    while (
+      targetDate.getTime() <= to.getTime() &&
+      targetDateTimes.length < 30
+    ) {
+      targetDateTimes.push(new Date(targetDate));
+      targetDate.setMinutes(targetDate.getMinutes() + 1);
+    }
+    return targetDateTimes;
+  };
+  findTargetDateAndUpdateLastExecutionDateTime = async (
+    spreadsheetUrl: string,
+    now: Date,
+  ): Promise<Date[]> => {
+    const sheetValues = await this.spreadsheetRepository.getSheet(
+      spreadsheetUrl,
+      'HandleScheduledEvent',
+    );
+    if (!sheetValues) {
+      await this.spreadsheetRepository.updateCell(
+        spreadsheetUrl,
+        'HandleScheduledEvent',
+        1,
+        1,
+        'LastExecutionDateTime',
+      );
+    }
+    const lastExecutionDateTime =
+      sheetValues && sheetValues[1][2] ? new Date(sheetValues[1][2]) : null;
+
+    const targetDateTimes: Date[] = lastExecutionDateTime
+      ? HandleScheduledEventUseCase.createTargetDateTimes(
+          lastExecutionDateTime,
+          now,
+        )
+      : [now];
+
+    await this.spreadsheetRepository.updateCell(
+      spreadsheetUrl,
+      'HandleScheduledEvent',
+      1,
+      2,
+      targetDateTimes[targetDateTimes.length - 1].toISOString(),
+    );
+    return targetDateTimes;
+  };
+}

package/src/domain/usecases/SetWorkflowManagementIssueToStoryUseCase.ts

@@ -0,0 +1,46 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+
+export class SetWorkflowManagementIssueToStoryUseCase {
+  constructor(readonly issueRepository: Pick<IssueRepository, 'updateStory'>) {}
+
+  run = async (input: {
+    targetDates: Date[];
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+  }): Promise<void> => {
+    const story = input.project.story;
+    if (
+      !story ||
+      input.cacheUsed ||
+      !input.targetDates.find((targetDate) => targetDate.getMinutes() === 0)
+    ) {
+      return;
+    }
+    const isTargetIssue = (issue: Issue): boolean => {
+      return (
+        (issue.labels.includes('story:workflow-management') ||
+          issue.labels.includes('daily-routine') ||
+          issue.isPr) &&
+        (issue.nextActionDate === null ||
+          issue.nextActionDate.getTime() <= input.targetDates[0].getTime()) &&
+        issue.nextActionHour === null &&
+        issue.state === 'OPEN' &&
+        issue.story === null
+      );
+    };
+    for (const issue of input.issues) {
+      if (!isTargetIssue(issue)) {
+        continue;
+      }
+      await this.issueRepository.updateStory(
+        { ...input.project, story },
+        issue,
+        story.workflowManagementStory.id,
+      );
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  };
+}

package/src/domain/usecases/adapter-interfaces/DateRepository.ts

@@ -0,0 +1,5 @@
+export interface DateRepository {
+  now(): Promise<Date>;
+  formatDurationToHHMM(durationMinutes: number): string;
+  formatDateTimeWithDayOfWeek(date: Date): string;
+}

package/src/domain/usecases/adapter-interfaces/IssueRepository.ts

@@ -0,0 +1,44 @@
+import { Issue, Label } from '../../entities/Issue';
+import { Project } from '../../entities/Project';
+import { Member } from '../../entities/Member';
+
+export interface IssueRepository {
+  getAllIssues: (
+    projectId: Project['id'],
+    allowCacheMinutes: number,
+  ) => Promise<{ issues: Issue[]; cacheUsed: boolean }>;
+  getIssueByUrl: (url: string) => Promise<Issue | null>;
+  createNewIssue: (
+    org: string,
+    repo: string,
+    title: string,
+    body: string,
+    assignees: Member['name'][],
+    labels: Label[],
+  ) => Promise<void>;
+  updateIssue: (issue: Issue) => Promise<void>;
+  updateNextActionDate: (
+    project: Project & {
+      nextActionDate: NonNullable<Project['nextActionDate']>;
+    },
+    issue: Issue,
+    date: Date,
+  ) => Promise<void>;
+  updateNextActionHour: (
+    project: Project & {
+      nextActionHour: NonNullable<Project['nextActionHour']>;
+    },
+    issue: Issue,
+    hour: number,
+  ) => Promise<void>;
+  updateStory: (
+    project: Project & { story: NonNullable<Project['story']> },
+    issue: Issue,
+    storyId: string,
+  ) => Promise<void>;
+  clearProjectField: (
+    project: Project,
+    fieldId: string,
+    issue: Issue,
+  ) => Promise<void>;
+}

package/src/domain/usecases/adapter-interfaces/ProjectRepository.ts

@@ -0,0 +1,6 @@
+import { Project } from '../../entities/Project';
+
+export interface ProjectRepository {
+  findProjectIdByUrl: (projectUrl: string) => Promise<Project['id'] | null>;
+  getProject: (projectId: Project['id']) => Promise<Project | null>;
+}

package/src/domain/usecases/adapter-interfaces/SlackRepository.ts

@@ -0,0 +1,20 @@
+export interface SlackRepository {
+  postMessageToChannel: (
+    message: string,
+    channelName: string,
+  ) => Promise<{ threadTs: string }>;
+  postMessageToChannelThread: (
+    message: string,
+    channelName: string,
+    threadTs: string,
+  ) => Promise<void>;
+  postMessageToChannelWithImage: (
+    message: string,
+    channelName: string,
+    imageFilePath: string,
+  ) => Promise<void>;
+  postMessageToDirectMessage: (
+    message: string,
+    userName: string,
+  ) => Promise<void>;
+}

package/src/domain/usecases/adapter-interfaces/SpreadsheetRepository.ts

@@ -0,0 +1,18 @@
+export interface SpreadsheetRepository {
+  getSheet: (
+    spreadsheetUrl: string,
+    sheetName: string,
+  ) => Promise<string[][] | null>;
+  updateCell: (
+    spreadsheetUrl: string,
+    sheetName: string,
+    row: number,
+    column: number,
+    value: string,
+  ) => Promise<void>;
+  appendSheetValues: (
+    spreadsheetUrl: string,
+    sheetName: string,
+    values: string[][],
+  ) => Promise<void>;
+}

package/src/index.test.ts

@@ -0,0 +1,8 @@
+import { hello } from './index';
+
+describe('index', () => {
+  test('hello', async () => {
+    const res = hello('test');
+    expect(res).toEqual('hello test');
+  });
+});

package/src/index.ts

@@ -0,0 +1,7 @@
+import dotenv from 'dotenv';
+import { HandleScheduledEventUseCaseHandler } from './adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler';
+dotenv.config();
+export const hello = (name: string) => `hello ${name}`;
+export { Project } from './domain/entities/Project';
+export { Issue } from './domain/entities/Issue';
+export const scheduledEvent = new HandleScheduledEventUseCaseHandler().handle;

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*", "**/*.test.ts"],
+  "compilerOptions": {
+    "outDir": "bin",
+    "declaration": true,
+    "declarationMap": true,
+    "declarationDir": "types"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "outDir": "./dist",
+    "sourceMap": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "plugins": [
+      {
+        "transform": "typia/lib/transform"
+      }
+    ],
+    "strictNullChecks": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*"]
+}

package/types/adapter/entry-points/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/types/adapter/entry-points/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":""}

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts

@@ -0,0 +1,11 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { Project } from '../../../domain/entities/Project';
+export declare class HandleScheduledEventUseCaseHandler {
+    handle: (configFilePath: string) => Promise<{
+        project: Project;
+        issues: Issue[];
+        cacheUsed: boolean;
+        targetDateTimes: Date[];
+    }>;
+}
+//# sourceMappingURL=HandleScheduledEventUseCaseHandler.d.ts.map

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAE3D,qBAAa,kCAAkC;IAC7C,MAAM,mBACY,MAAM,KACrB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,CAAC,CA8DA;CACH"}

package/types/adapter/repositories/AxiosSlackRepository.d.ts

@@ -0,0 +1,13 @@
+import { SlackRepository } from '../../domain/usecases/adapter-interfaces/SlackRepository';
+export declare class AxiosSlackRepository implements SlackRepository {
+    private readonly client;
+    private readonly baseUrl;
+    constructor(userToken: string);
+    postMessageToChannel(message: string, channelName: string): Promise<{
+        threadTs: string;
+    }>;
+    postMessageToChannelThread(message: string, channelName: string, threadTs: string): Promise<void>;
+    postMessageToDirectMessage(message: string, userName: string): Promise<void>;
+    postMessageToChannelWithImage(message: string, channelName: string, imageFilePath: string): Promise<void>;
+}
+//# sourceMappingURL=AxiosSlackRepository.d.ts.map

package/types/adapter/repositories/AxiosSlackRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxiosSlackRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/AxiosSlackRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,0DAA0D,CAAC;AAE3F,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;gBAEvC,SAAS,EAAE,MAAM;IAYvB,oBAAoB,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;QACT,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IAwBI,0BAA0B,CAC9B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAmBV,0BAA0B,CAC9B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAiBV,6BAA6B,CACjC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;CAuFjB"}

package/types/adapter/repositories/BaseGitHubRepository.d.ts

@@ -0,0 +1,32 @@
+interface Cookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+}
+export declare class BaseGitHubRepository {
+    readonly jsonFilePath: string;
+    readonly ghToken: string;
+    readonly ghUserName: string | undefined;
+    readonly ghUserPassword: string | undefined;
+    readonly ghAuthenticatorKey: string | undefined;
+    cookie: string | null;
+    constructor(jsonFilePath?: string, ghToken?: string, ghUserName?: string | undefined, ghUserPassword?: string | undefined, ghAuthenticatorKey?: string | undefined);
+    protected extractIssueFromUrl: (issueUrl: string) => {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+        isIssue: boolean;
+    };
+    getCookie: () => Promise<string>;
+    createHeader: () => Promise<object>;
+    protected createCookieStringFromFile: () => Promise<string>;
+    protected isCookie: (cookie: object) => cookie is Cookie;
+    protected generateCookieHeaderFromJson: (cookieData: unknown) => Promise<string>;
+}
+export {};
+//# sourceMappingURL=BaseGitHubRepository.d.ts.map

package/types/adapter/repositories/BaseGitHubRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseGitHubRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/BaseGitHubRepository.ts"],"names":[],"mappings":"AAgBA,UAAU,MAAM;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;CACtC;AAED,qBAAa,oBAAoB;IAG7B,QAAQ,CAAC,YAAY,EAAE,MAAM;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;IACvC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS;IAC3C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS;IANjD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEX,YAAY,GAAE,MAAwC,EACtD,OAAO,GAAE,MAAwC,EACjD,UAAU,GAAE,MAAM,GAAG,SAAoC,EACzD,cAAc,GAAE,MAAM,GAAG,SAAwC,EACjE,kBAAkB,GAAE,MAAM,GAAG,SACf;IAIzB,SAAS,CAAC,mBAAmB,aACjB,MAAM,KACf;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAevE;IAEF,SAAS,QAAa,OAAO,CAAC,MAAM,CAAC,CAKnC;IACF,YAAY,QAAa,OAAO,CAAC,MAAM,CAAC,CAwBtC;IACF,SAAS,CAAC,0BAA0B,QAAa,OAAO,CAAC,MAAM,CAAC,CAqB9D;IACF,SAAS,CAAC,QAAQ,WAAY,MAAM,KAAG,MAAM,IAAI,MAAM,CAoBrD;IAEF,SAAS,CAAC,4BAA4B,eACxB,OAAO,KAClB,OAAO,CAAC,MAAM,CAAC,CAmChB;CACH"}

package/types/adapter/repositories/GoogleSpreadsheetRepository.d.ts

@@ -0,0 +1,13 @@
+import { SpreadsheetRepository } from '../../domain/usecases/adapter-interfaces/SpreadsheetRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+export declare class GoogleSpreadsheetRepository implements SpreadsheetRepository {
+    readonly localStorageRepository: LocalStorageRepository;
+    keyFile: string;
+    constructor(localStorageRepository: LocalStorageRepository, serviceAccountKey?: string);
+    getSpreadsheetId: (spreadsheetUrl: string) => string;
+    getSheet: (spreadsheetUrl: string, sheetName: string) => Promise<string[][] | null>;
+    updateCell: (spreadsheetUrl: string, sheetName: string, row: number, column: number, value: string) => Promise<void>;
+    createNewSheetIfNotExists: (spreadsheetUrl: string, sheetName: string) => Promise<void>;
+    appendSheetValues: (spreadsheetUrl: string, sheetName: string, values: string[][]) => Promise<void>;
+}
+//# sourceMappingURL=GoogleSpreadsheetRepository.d.ts.map

package/types/adapter/repositories/GoogleSpreadsheetRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoogleSpreadsheetRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/GoogleSpreadsheetRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gEAAgE,CAAC;AAEvG,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,qBAAa,2BAA4B,YAAW,qBAAqB;IAIrE,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB;IAHzD,OAAO,SAAoC;gBAGhC,sBAAsB,EAAE,sBAAsB,EACvD,iBAAiB,GAAE,MACV;IAKX,gBAAgB,mBAAoB,MAAM,KAAG,MAAM,CAGjD;IACF,QAAQ,mBACU,MAAM,aACX,MAAM,KAChB,OAAO,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,CAkC3B;IACF,UAAU,mBACQ,MAAM,aACX,MAAM,OACZ,MAAM,UACH,MAAM,SACP,MAAM,KACZ,OAAO,CAAC,IAAI,CAAC,CAqBd;IACF,yBAAyB,mBACP,MAAM,aACX,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CA8Bd;IAEF,iBAAiB,mBACC,MAAM,aACX,MAAM,UACT,MAAM,EAAE,EAAE,KACjB,OAAO,CAAC,IAAI,CAAC,CAuBd;CACH"}

package/types/adapter/repositories/GraphqlProjectRepository.d.ts

@@ -0,0 +1,13 @@
+import { BaseGitHubRepository } from './BaseGitHubRepository';
+import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
+import { Project } from '../../domain/entities/Project';
+export declare class GraphqlProjectRepository extends BaseGitHubRepository implements ProjectRepository {
+    extractProjectFromUrl: (projectUrl: string) => {
+        owner: string;
+        projectNumber: number;
+    };
+    fetchProjectId: (login: string, projectNumber: number) => Promise<string>;
+    findProjectIdByUrl: (projectUrl: string) => Promise<Project["id"] | null>;
+    getProject: (projectId: Project["id"]) => Promise<Project | null>;
+}
+//# sourceMappingURL=GraphqlProjectRepository.d.ts.map

package/types/adapter/repositories/GraphqlProjectRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphqlProjectRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/GraphqlProjectRepository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4DAA4D,CAAC;AAC/F,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAGxD,qBAAa,wBACX,SAAQ,oBACR,YAAW,iBAAiB;IAE5B,qBAAqB,eACP,MAAM,KACjB;QACD,KAAK,EAAE,MAAM,CAAC;QACd,aAAa,EAAE,MAAM,CAAC;KACvB,CAMC;IACF,cAAc,UACL,MAAM,iBACE,MAAM,KACpB,OAAO,CAAC,MAAM,CAAC,CAkDhB;IACF,kBAAkB,eACJ,MAAM,KACjB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAG9B;IACF,UAAU,cAAqB,OAAO,CAAC,IAAI,CAAC,KAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAwJpE;CACH"}

package/types/adapter/repositories/LocalStorageCacheRepository.d.ts

@@ -0,0 +1,12 @@
+import { LocalStorageRepository } from './LocalStorageRepository';
+export declare class LocalStorageCacheRepository {
+    readonly localStorageRepository: LocalStorageRepository;
+    readonly cachePath: string;
+    constructor(localStorageRepository: LocalStorageRepository, cachePath?: string);
+    getLatest: (key: string) => Promise<{
+        value: object;
+        timestamp: Date;
+    } | null>;
+    set: <T>(key: string, value: T) => Promise<void>;
+}
+//# sourceMappingURL=LocalStorageCacheRepository.d.ts.map

package/types/adapter/repositories/LocalStorageCacheRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalStorageCacheRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/LocalStorageCacheRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,qBAAa,2BAA2B;IAEpC,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB;IACvD,QAAQ,CAAC,SAAS;gBADT,sBAAsB,EAAE,sBAAsB,EAC9C,SAAS,SAAgB;IAGpC,SAAS,QACF,MAAM,KACV,OAAO,CAAC;QACT,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,IAAI,CAAC;KACjB,GAAG,IAAI,CAAC,CA6BP;IACF,GAAG,GAAU,CAAC,OAAO,MAAM,SAAS,CAAC,KAAG,OAAO,CAAC,IAAI,CAAC,CAQnD;CACH"}

package/types/adapter/repositories/LocalStorageRepository.d.ts

@@ -0,0 +1,7 @@
+export declare class LocalStorageRepository {
+    write: (path: string, value: string) => void;
+    read: (path: string) => string | null;
+    listFiles: (dirPath: string) => string[];
+    mkdir: (dirPath: string) => void;
+}
+//# sourceMappingURL=LocalStorageRepository.d.ts.map

package/types/adapter/repositories/LocalStorageRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalStorageRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/LocalStorageRepository.ts"],"names":[],"mappings":"AAEA,qBAAa,sBAAsB;IACjC,KAAK,SAAU,MAAM,SAAS,MAAM,UAIlC;IACF,IAAI,SAAU,MAAM,KAAG,MAAM,GAAG,IAAI,CAElC;IACF,SAAS,YAAa,MAAM,KAAG,MAAM,EAAE,CAKrC;IACF,KAAK,YAAa,MAAM,UAEtB;CACH"}

package/types/adapter/repositories/SystemDateRepository.d.ts

@@ -0,0 +1,7 @@
+import { DateRepository } from '../../domain/usecases/adapter-interfaces/DateRepository';
+export declare class SystemDateRepository implements DateRepository {
+    now: () => Promise<Date>;
+    formatDurationToHHMM: (durationMinutes: number) => string;
+    formatDateTimeWithDayOfWeek: (date: Date) => string;
+}
+//# sourceMappingURL=SystemDateRepository.d.ts.map

package/types/adapter/repositories/SystemDateRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemDateRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/SystemDateRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AAEzF,qBAAa,oBAAqB,YAAW,cAAc;IACzD,GAAG,sBAA0B;IAC7B,oBAAoB,oBAAqB,MAAM,KAAG,MAAM,CAItD;IACF,2BAA2B,SAAU,IAAI,KAAG,MAAM,CAShD;CACH"}