firstly 0.0.1 → 0.0.2

package/esm/cron/index.js

@@ -0,0 +1,102 @@
+import { CronJob } from 'cron';
+import { green, Log, magenta, red, yellow } from '@kitql/helpers';
+const log = new Log('firstly | cron');
+export const jobs = {};
+/**
+ * Link to a nice Cheatsheet TODO
+ */
+export const cronTime = {
+    /**
+     * Every morning is actually at 4 am and 7 minutes. (because I like this number!)
+     */
+    every_morning: '0 7 4 * * *',
+    /**
+     * Every second
+     */
+    every_second: '* * * * * *',
+    /**
+     * Every minute
+     */
+    every_minute: '0 * * * * *',
+    /**
+     * Every 10 minute
+     */
+    every_10_minute: '*/10 * * * *',
+    /**
+     * Every friday at 5:11 am
+     */
+    every_friday_morning: '11 5 * * 5',
+};
+/**
+ * usage:
+ *
+ * ```ts
+ * import { cron, cronTime } from 'firstly/cron'
+ *
+ * export const api = firstly({
+ *   modules: [
+ *     cron([{
+ *       topic: 'first_cron',
+ *       cronTime: cronTime.every_second,
+ *       onTick: () => { console.log('hello') },
+ *       start: !dev, // Start in production
+ *       // runOnInit: dev, // nice in dev environement
+ *     }])
+ *   ]
+ * })
+ * ```
+ *
+ * using [cron](https://www.npmjs.com/package/cron) library under the hood
+ */
+export const cron = (jobsInfos) => {
+    return {
+        name: 'cron',
+        initApi: async () => {
+            jobsInfos.forEach((infos) => {
+                const { topic, runOnInit, logs, concurrent, ...params } = infos;
+                const concurrentToUse = concurrent ?? 1;
+                const onTickSaved = params.onTick;
+                const fullOnTick = async () => {
+                    if (jobs[topic].concurrentInProgress < concurrentToUse) {
+                        jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress + 1;
+                        if (logs?.starting === undefined || logs?.starting === true) {
+                            logJobs(topic, job, 'starting...', false, false);
+                        }
+                        // @ts-ignore
+                        await onTickSaved();
+                        if (logs?.ended === undefined || logs?.ended === true) {
+                            logJobs(topic, job, 'done');
+                        }
+                        jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress - 1;
+                    }
+                    else {
+                        logJobs(topic, job, `skipped because of concurrent limit (${yellow(concurrentToUse.toString())})`, false, false);
+                    }
+                };
+                params.onTick = fullOnTick;
+                const job = CronJob.from(params);
+                jobs[topic] = { job, concurrentInProgress: 0 };
+                logJobs(topic, job, 'setup done');
+                // If not it will be done too early
+                if (runOnInit) {
+                    job.fireOnTick();
+                }
+            });
+        },
+    };
+};
+const logJobs = (topic, job, message, with_metadata = true, isSuccess = true) => {
+    const l = [];
+    l.push(magenta(`[${topic}]`));
+    l.push(message);
+    if (with_metadata) {
+        // If the job is "stopped", there will still be a next date, but it will not fire it. The job has to start.
+        l.push(`(${job.running ? green('running') : red('stopped')}, next at ${yellow(job.nextDate().toISO())})`);
+    }
+    if (isSuccess) {
+        log.success(l.join(' '));
+    }
+    else {
+        log.info(l.join(' '));
+    }
+};

package/esm/feedback/FeedbackController.d.ts

@@ -0,0 +1,30 @@
+export declare class FeedbackController {
+    static getMilestones(): Promise<{
+        title: string;
+        id: string;
+        number: number;
+    }[]>;
+    static getIssues(milestoneNumber: number, issueState: 'OPEN' | 'CLOSED'): Promise<{
+        id: string;
+        number: number;
+        titleHTML: string;
+        state: 'OPEN' | 'CLOSED';
+    }[]>;
+    static getIssue(issueNumber: number): Promise<{
+        id: any;
+        state: any;
+        items: {
+            bodyHTML: string;
+            who?: string | undefined;
+            createdAt: Date;
+            public: boolean;
+        }[];
+    }>;
+    static createIssue(milestoneId: string, title: string, body: string, page: string): Promise<{
+        id: string;
+        number: number;
+    }>;
+    static addCommentOnIssue(issueId: string, body: string, page: string): Promise<string>;
+    static close(issueId: string): Promise<string>;
+    static reOpen(issueId: string): Promise<string>;
+}

package/esm/feedback/FeedbackController.js

@@ -0,0 +1,313 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Allow, BackendMethod, remult } from 'remult';
+import { stry } from '@kitql/helpers';
+import { FEEDBACK_OPTIONS } from '.';
+const GITHUB_GRAPHQL_ENDPOINT = 'https://api.github.com/graphql';
+async function getGitHub(query, variables) {
+    if (!FEEDBACK_OPTIONS.GITHUB_API_TOKEN) {
+        throw new Error('GITHUB_API_TOKEN not found in .env');
+    }
+    try {
+        const headers = new Headers({
+            Authorization: 'Bearer ' + FEEDBACK_OPTIONS.GITHUB_API_TOKEN,
+            'Content-Type': 'application/json',
+        });
+        const body = stry({ query, variables }, 0);
+        const response = await fetch(GITHUB_GRAPHQL_ENDPOINT, { method: 'POST', headers, body });
+        const result = await response.json();
+        if (result.errors) {
+            /* eslint-disable */
+            console.error(`result ERRORS`, body, stry(result));
+        }
+        return result.data;
+    }
+    catch (error) {
+        /* eslint-disable */
+        console.error(`error`, error);
+    }
+    return null;
+}
+async function addMetaData(issueId, author, page) {
+    const commentToMinimize = await getGitHub(`mutation AddComment($input: AddCommentInput!) {
+			addComment(input: $input) {
+				commentEdge {
+					node {
+						id
+					}
+				}
+			}
+		}
+		`, {
+        input: {
+            subjectId: issueId,
+            body: `<pre>\n${JSON.stringify({ author, page }, null, 2)}\n</pre>`,
+        },
+    });
+    await getGitHub(`mutation MinimizeComment($input: MinimizeCommentInput!) {
+			minimizeComment(input: $input) {
+				minimizedComment {
+					isMinimized
+				}
+			}
+		}
+		`, {
+        input: {
+            subjectId: commentToMinimize.addComment.commentEdge.node.id,
+            classifier: 'OFF_TOPIC',
+        },
+    });
+}
+export class FeedbackController {
+    static async getMilestones() {
+        const data = await getGitHub(`query Milestones(
+			$repository: String!
+			$owner: String!
+			$filter: String
+			$take: Int = 25
+			$cursor: String
+		) {
+			repository(name: $repository, owner: $owner) {
+				milestones(query: $filter, last: $take, after: $cursor, states: OPEN) {
+					pageInfo {
+						endCursor
+					}
+					nodes {
+						id
+						number
+						title
+					}
+				}
+			}
+		}
+		`, {
+            repository: FEEDBACK_OPTIONS.repo.name,
+            owner: FEEDBACK_OPTIONS.repo.owner,
+            filter: FEEDBACK_OPTIONS.milestones?.title_filter ?? '',
+        });
+        return data.repository.milestones.nodes.map((c) => {
+            return {
+                ...c,
+                title: c.title.replaceAll(FEEDBACK_OPTIONS.milestones?.title_filter ?? '', '').trim(),
+            };
+        });
+    }
+    static async getIssues(milestoneNumber, issueState) {
+        const issueOrder = issueState === 'CLOSED'
+            ? { field: 'UPDATED_AT', direction: 'DESC' } // When close, the last issue updated.
+            : null; // When open take milestone order
+        const data = await getGitHub(`query Issues(
+				$repository: String!
+				$owner: String!
+				$filters: IssueFilters
+				$milestoneNumber: Int!
+				$take: Int = 25
+				$cursor: String
+				$issueOrder: IssueOrder
+			) {
+				repository(name: $repository, owner: $owner) {
+					milestone(number: $milestoneNumber) {
+						issues(first: $take, after: $cursor, filterBy: $filters, orderBy: $issueOrder) {
+							nodes {
+								id
+								number
+								titleHTML
+								state
+							}
+						}
+					}
+				}
+			}			
+		`, {
+            repository: FEEDBACK_OPTIONS.repo.name,
+            owner: FEEDBACK_OPTIONS.repo.owner,
+            milestoneNumber,
+            filters: {
+                labels: FEEDBACK_OPTIONS.milestones?.labels_filters ?? [],
+                states: [issueState],
+            },
+            issueOrder,
+        });
+        return data.repository.milestone.issues.nodes;
+    }
+    static async getIssue(issueNumber) {
+        const data = await getGitHub(`query Issue($repository: String!, $owner: String!, $issueNumber: Int!) {
+				repository(name: $repository, owner: $owner) {
+					issue(number: $issueNumber) {
+						id
+						createdAt
+						bodyHTML
+						state
+						comments(first: 100) {
+							nodes {
+								id
+								isMinimized
+								createdAt
+								body
+								bodyHTML
+								reactionGroups {
+									content
+									reactors(first: 1) {
+										totalCount
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		`, {
+            repository: FEEDBACK_OPTIONS.repo.name,
+            owner: FEEDBACK_OPTIONS.repo.owner,
+            issueNumber,
+        });
+        const items = [];
+        const firstItem = {
+            bodyHTML: data.repository.issue.bodyHTML,
+            createdAt: data.repository.issue.createdAt,
+            public: true,
+        };
+        items.push(firstItem);
+        const comments = data.repository.issue.comments.nodes;
+        for (let i = 0; i < comments.length; i++) {
+            if (comments[i].isMinimized) {
+                const parsed = JSON.parse(comments[i].body.replaceAll('<pre>\n', '').replaceAll('\n</pre>', ''));
+                items[items.length - 1].who = parsed.author;
+                items[items.length - 1].public = true;
+            }
+            else {
+                const nbEye = comments[i].reactionGroups.find((c) => c.content === 'EYES')?.reactors
+                    .totalCount;
+                items.push({
+                    bodyHTML: comments[i].bodyHTML,
+                    createdAt: new Date(comments[i].createdAt),
+                    public: nbEye && nbEye > 0 ? true : false,
+                });
+            }
+        }
+        const toRet = {
+            id: data.repository.issue.id,
+            state: data.repository.issue.state,
+            items: items.filter((c) => c.public),
+        };
+        return toRet;
+    }
+    static async createIssue(milestoneId, title, body, page) {
+        const repoInfo = await getGitHub(`query RepoInfo(
+				$repository: String!
+				$owner: String!
+			) {
+				repository(name: $repository, owner: $owner) {
+					id
+          labels(first: 25){
+            nodes{
+              id
+              name
+            }
+          }
+				}
+			}`, {
+            repository: FEEDBACK_OPTIONS.repo.name,
+            owner: FEEDBACK_OPTIONS.repo.owner,
+        });
+        const repoInfoData = repoInfo.repository;
+        const create_label = repoInfoData.labels.nodes.find((c) => c.name === FEEDBACK_OPTIONS.create_label);
+        const newIssue = await getGitHub(`mutation CreateIssue($input: CreateIssueInput!) {
+			createIssue(input: $input) {
+				issue {
+					id
+					number
+				}
+			}
+		}
+		`, {
+            input: {
+                repositoryId: repoInfoData.id,
+                milestoneId: milestoneId,
+                labelIds: [create_label?.id],
+                title: title ?? 'New Feedback (wo title...)',
+                body: body,
+            },
+        });
+        const toRet = newIssue.createIssue.issue;
+        await addMetaData(toRet.id, remult.user?.name, page);
+        return toRet;
+    }
+    static async addCommentOnIssue(issueId, body, page) {
+        const input = {
+            subjectId: issueId,
+            body,
+        };
+        await getGitHub(`mutation AddComment($input: AddCommentInput!) {
+				addComment(input: $input) {
+					commentEdge {
+						node {
+							id
+						}
+					}
+				}
+			}
+			`, {
+            input,
+        });
+        await addMetaData(issueId, remult.user?.name, page);
+        return 'done';
+    }
+    static async close(issueId) {
+        const input = {
+            issueId,
+        };
+        await getGitHub(`mutation CloseIssue($input: CloseIssueInput!) {
+				closeIssue(input: $input) {
+					issue {
+						id
+					}
+				}
+			}
+			`, {
+            input,
+        });
+        return 'done';
+    }
+    static async reOpen(issueId) {
+        const input = {
+            issueId,
+        };
+        await getGitHub(`mutation ReOpenIssue($input: ReopenIssueInput!) {
+				reopenIssue(input: $input) {
+					issue {
+						id
+					}
+				}
+			}
+			`, {
+            input,
+        });
+        return 'done';
+    }
+}
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "getMilestones", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "getIssues", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "getIssue", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "createIssue", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "addCommentOnIssue", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "close", null);
+__decorate([
+    BackendMethod({ allowed: Allow.authenticated })
+], FeedbackController, "reOpen", null);

package/esm/feedback/index.d.ts

@@ -0,0 +1,18 @@
+import type { Module } from '../api';
+import { FeedbackController } from './FeedbackController';
+import { default as Feedback } from './ui/Feedback.svelte';
+export { FeedbackController, Feedback };
+type FeedbackOptions = {
+    GITHUB_API_TOKEN: string;
+    repo: {
+        owner: string;
+        name: string;
+    };
+    milestones?: {
+        title_filter?: string;
+        labels_filters?: string[];
+    };
+    create_label?: string;
+};
+export declare let FEEDBACK_OPTIONS: FeedbackOptions;
+export declare const feedback: (o: FeedbackOptions) => Module;

package/esm/feedback/index.js

@@ -0,0 +1,14 @@
+import { FeedbackController } from './FeedbackController';
+import { default as Feedback } from './ui/Feedback.svelte';
+export { FeedbackController, Feedback };
+export let FEEDBACK_OPTIONS = {
+    GITHUB_API_TOKEN: '',
+    repo: { owner: '', name: '' },
+};
+export const feedback = (o) => {
+    FEEDBACK_OPTIONS = o;
+    return {
+        name: 'feedback',
+        controllers: [FeedbackController],
+    };
+};

package/esm/feedback/ui/DialogIssue.svelte

@@ -0,0 +1,102 @@
+<script>import { onMount } from "svelte";
+import { repo } from "remult";
+import { page } from "$app/stores";
+import { FeedbackController } from "..";
+import { Button, Field, FilterEntity, kitCellBuildor, Loading } from "../..";
+import Textarea from "../../ui/internals/Textarea.svelte";
+export let dialogId;
+const rmvWarning = dialogId;
+export let milestoneId;
+export let issueNumber;
+let state = "loading";
+let issue;
+const update = async () => {
+  state = "loading";
+  if (issueNumber) {
+    issue = await FeedbackController.getIssue(issueNumber);
+  }
+  state = "done";
+};
+onMount(async () => {
+  await update();
+});
+let title;
+let content;
+const send = async () => {
+  state = "loading";
+  const p = $page.url.pathname + $page.url.search;
+  if (!issue?.id) {
+    const result = await FeedbackController.createIssue(milestoneId, title, content, p);
+    issueNumber = result.number;
+  } else {
+    await FeedbackController.addCommentOnIssue(issue.id, content, p);
+  }
+  content = "";
+  await update();
+};
+const close = async () => {
+  state = "loading";
+  await FeedbackController.close(issue.id);
+  content = "";
+  await update();
+};
+const reOpen = async () => {
+  state = "loading";
+  await FeedbackController.reOpen(issue.id);
+  content = "";
+  await update();
+};
+</script>
+
+<div class="mb-4 grid gap-4">
+  {#if state === 'loading'}
+    <Loading class="h-12"></Loading>
+    <Loading class="h-12"></Loading>
+    <Loading class="h-12"></Loading>
+  {:else}
+    {#each issue?.items ?? [] as item}
+      <div class="chat {item.who ? 'chat-start' : 'chat-end'}">
+        <div class="avatar chat-image">
+          <div class="w-10 rounded-full">
+            <div class="h-10 w-10 {item.who ? 'bg-secondary' : 'bg-primary'}"></div>
+          </div>
+        </div>
+        <div class="chat-header">
+          {item.who ?? 'Support'}
+          <time class="text-xs opacity-50"
+            >{new Date(item.createdAt).toLocaleDateString()} - {new Date(
+              item.createdAt,
+            ).toLocaleTimeString()}</time
+          >
+        </div>
+        <div class="chat-bubble">{@html item.bodyHTML}</div>
+        <!-- <div class="chat-footer opacity-50">Delivered</div> -->
+      </div>
+    {/each}
+
+    {#if issueNumber}
+      <button on:click={update} class="divider"></button>
+    {/if}
+
+    {#if issue?.state === 'CLOSED'}
+      <div class="flex justify-end">
+        <Button on:click={reOpen} class="btn-neutral">Re Ouvrir</Button>
+      </div>
+    {:else}
+      {#if issueNumber === null}
+        <Field cell={kitCellBuildor(repo(FilterEntity), 'title')} bind:value={title} />
+      {/if}
+      <Textarea bind:value={content}></Textarea>
+      <div class="flex justify-between">
+        {#if issueNumber}
+          <Button on:click={close} tabIndex={-1} class="btn-outline btn-error"
+            >Clore le feedback</Button
+          >
+        {:else}
+          <div></div>
+        {/if}
+        <Button on:click={send} disabled={content?.length < 3}>Envoyer</Button>
+      </div>
+    {/if}
+  {/if}
+</div>

package/esm/feedback/ui/DialogIssue.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        dialogId: number;
+        milestoneId: string;
+        issueNumber: number | null;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type DialogIssueProps = typeof __propDef.props;
+export type DialogIssueEvents = typeof __propDef.events;
+export type DialogIssueSlots = typeof __propDef.slots;
+export default class DialogIssue extends SvelteComponent<DialogIssueProps, DialogIssueEvents, DialogIssueSlots> {
+}
+export {};

package/esm/feedback/ui/DialogIssues.svelte

@@ -0,0 +1,91 @@
+<script>import { onMount } from "svelte";
+import { FeedbackController } from "..";
+import {
+  Button,
+  dialog,
+  Icon,
+  LibIcon_Add,
+  LibIcon_Check,
+  LibIcon_Search,
+  Loading
+} from "../..";
+import DialogIssue from "./DialogIssue.svelte";
+export let dialogId;
+const rmvWarning = dialogId;
+export let milestoneNumber;
+export let milestoneId;
+let state = "loading";
+let issueState = "OPEN";
+let issues = [];
+const update = async (_issueState) => {
+  issueState = _issueState;
+  state = "loading";
+  issues = await FeedbackController.getIssues(milestoneNumber, issueState);
+  state = "done";
+};
+onMount(async () => {
+  await update(issueState);
+});
+</script>
+
+<div class="mb-4 grid gap-4">
+  <div class="flex justify-between">
+    <div>
+      <Button
+        class={issueState === 'OPEN' ? 'btn-primary' : 'btn-ghost'}
+        on:click={() => update('OPEN')}>En cours</Button
+      >
+      <Button
+        class={issueState === 'CLOSED' ? 'btn-primary' : 'btn-ghost'}
+        on:click={() => update('CLOSED')}>Clos</Button
+      >
+    </div>
+
+    <Button
+      on:click={async () => {
+        await dialog.show({
+          component: DialogIssue,
+          classes: { root: 'overflow-auto w-5/6 h-5/6' },
+          props: { issueNumber: null, milestoneId },
+          detail: {
+            caption: 'Nouveau Feedback',
+            icon: { data: LibIcon_Search },
+          },
+        })
+        await update(issueState)
+      }}
+    >
+      <Icon data={LibIcon_Add}></Icon>
+    </Button>
+  </div>
+
+  {#each issues as issue}
+    <Button
+      on:click={async () => {
+        await dialog.show({
+          component: DialogIssue,
+          classes: { root: 'overflow-auto w-5/6 h-5/6' },
+          props: { issueNumber: issue.number, milestoneId },
+          detail: {
+            caption: issue.titleHTML,
+            icon: { data: issue.state === 'OPEN' ? LibIcon_Search : LibIcon_Check },
+          },
+        })
+        await update(issueState)
+      }}
+      class="btn-neutral"
+    >
+      <div class="w-full text-left">
+        {@html issue.titleHTML}
+      </div>
+    </Button>
+  {:else}
+    {#if state === 'loading'}
+      <Loading class="h-12"></Loading>
+      <Loading class="h-12"></Loading>
+      <Loading class="h-12"></Loading>
+    {:else}
+      <p>Nothing here</p>
+    {/if}
+  {/each}
+</div>