electrodb 1.4.3 → 1.4.7

package/notes

@@ -1,937 +0,0 @@
-import { Entity, Service, CollectionItem } from "electrodb";
-
-const StatusTypes = ["Open", "Closed", ""] as const;
-const IsNotTicket = "";
-const NotYetViewed = "#";
-const IssueTicket = "Issue";
-const PullRequestTicket = "PullRequest";
-const TicketTypes = [IssueTicket, PullRequestTicket, IsNotTicket] as const
-
-type Status = typeof StatusTypes[number];
-
-function toStatusCode(status: unknown): Status | undefined {
-    for (let index in StatusTypes) {
-        if (StatusTypes[index] === status) {
-            return index as Status;
-        }
-    }
-    return undefined;
-}
-
-function toStatusString(code: unknown): Status | undefined {
-    for (let index in StatusTypes) {
-        if (index === code) {
-            return StatusTypes[index];
-        }
-    }
-    return undefined;
-}
-
-
-const issues = new Entity({
-  model: {
-    entity: "issues",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    issueNumber: {
-      type: "string",
-    },
-    repoName: {
-      type: "string"
-    },
-    repoOwner: {
-      type: "string"
-    },
-    username: {
-      type: "string",
-    },
-    ticketType: {
-      type: TicketTypes,
-      set: () => IssueTicket,
-      readOnly: true
-    },
-    ticketNumber: {
-      type: "string",
-      readOnly: true,
-      watch: ["issueNumber"],
-      set: (_, {issueNumber}) => issueNumber
-    },
-    status: {
-      type: StatusTypes,
-      default: "Open",
-      set: (val) => toStatusCode(val),
-      get: (val) => toStatusString(val),
-    },
-    subject: {
-      type: "string"
-    },
-    body: {
-      type: "string"
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-      type: "string",
-      watch: "*",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-  },
-  indexes: {
-    issue: {
-      collection: "issueReview",
-      pk: {
-        composite: ["repoOwner", "repoName", "issueNumber"],
-        field: "pk"
-      },
-      sk: {
-        composite: [],
-        field: "sk"
-      }
-    },
-    created: {
-      collection: ["owned", "managed"],
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        field: "gsi1pk",
-        composite: ["username"]
-      },
-      sk: {
-        field: "gsi1sk",
-        composite: ["createdAt"]
-      }
-    },
-    todos: {
-      collection: "activity",
-      index: "gsi2pk-gsi2sk-index",
-      pk: {
-        composite: ["repoOwner", "repoName"],
-        field: "gsi2pk"
-      },
-      sk: {
-        composite: ["createdAt"],
-        field: "gsi2sk"
-      }
-    },
-    _: {
-      collection: "subscribers",
-      index: "gsi4pk-gsi4sk-index",
-      pk: {
-        composite: ["repoOwner", "repoName", "ticketNumber"],
-        field: "gsi4pk"
-      },
-      sk: {
-        composite: [],
-        field: "gsi4sk"
-      }
-    }
-  }
-});
-
-const issueComments = new Entity({
-  model: {
-    entity: "issueComment",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    issueNumber: {
-      type: "string",
-    },
-    commentId: {
-      type: "string"
-    },
-    username: {
-      type: "string"
-    },
-    replyTo: {
-      type: "string"
-    },
-    replyViewed: {
-      type: "string",
-      default: NotYetViewed,
-      get: (replyViewed): string | void => {
-        if (replyViewed !== NotYetViewed) {
-          return replyViewed
-        }
-      },
-      set: (replyViewed) => {
-        if (replyViewed === undefined) {
-          return NotYetViewed;
-        }
-        return replyViewed;
-      }
-    },
-    repoName: {
-      type: "string"
-    },
-    repoOwner: {
-      type: "string"
-    },
-    body: {
-      type: "string"
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-      type: "string",
-      watch: "*",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-  },
-  indexes: {
-    comments: {
-      collection: "issueReview",
-      pk: {
-        composite: ["repoOwner", "repoName", "issueNumber"],
-        field: "pk"
-      },
-      sk: {
-        composite: ["commentId"],
-        field: "sk"
-      }
-    },
-    created: {
-      collection: "conversations",
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        field: "gsi1pk",
-        composite: ["username"]
-      },
-      sk: {
-        field: "gsi1sk",
-        composite: ["repoOwner", "repoName", "issueNumber"]
-      }
-    },
-    replies: {
-      collection: "inbox",
-      index: "gsi2pk-gsi2sk-index",
-      pk: {
-        composite: ["replyTo"],
-        field: "gsi2pk"
-      },
-      sk: {
-        composite: ["createdAt", "replyViewed"],
-        field: "gsi2sk"
-      }
-    }
-  }
-});
-
-const pullRequests = new Entity({
-  model: {
-    entity: "pullRequest",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    pullRequestNumber: {
-      type: "string",
-      required: true,
-    },
-    repoName: {
-      type: "string",
-      required: true,
-    },
-    repoOwner: {
-      type: "string",
-      required: true,
-    },
-    username: {
-      type: "string",
-      required: true,
-    },
-    ticketType: {
-      type: TicketTypes,
-      default: () => PullRequestTicket,
-      set: () => PullRequestTicket,
-      readOnly: true
-    },
-    ticketNumber: {
-      type: "string",
-      readOnly: true,
-      watch: ["pullRequestNumber"],
-      set: (_, {issueNumber}) => issueNumber
-    },
-    status: {
-      type: StatusTypes,
-      default: "Open",
-      set: (val) => toStatusCode(val),
-      get: (val) => toStatusString(val)
-    },
-    reviewers: {
-      type: "list",
-      items: {
-        type: "map",
-        properties: {
-          username: {
-            type: "string",
-            required: true,
-          },
-          approved: {
-            type: "boolean",
-            required: true,
-          },
-          createdAt: {
-            type: "string",
-            default: () => new Date().toISOString().split('T')[0],
-            readOnly: true,
-          },
-        }
-      }
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-      type: "string",
-      watch: "*",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-  },
-  indexes: {
-    pullRequest: {
-      collection: "PRReview",
-      pk: {
-        composite: ["repoOwner", "repoName", "pullRequestNumber"],
-        field: "pk"
-      },
-      sk: {
-        composite: [],
-        field: "sk"
-      }
-    },
-    created: {
-      collection: ["owned", "managed"],
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        field: "gsi1pk",
-        composite: ["username"]
-      },
-      sk: {
-        field: "gsi1sk",
-        composite: ["createdAt"]
-      }
-    },
-    enhancements: {
-      collection: "activity",
-      index: "gsi2pk-gsi2sk-index",
-      pk: {
-        field: "gsi2pk",
-        composite: ["repoOwner", "repoName"],
-      },
-      sk: {
-        field: "gsi2sk",
-        composite: ["createdAt"],
-
-      }
-    },
-    _: {
-      collection: "subscribers",
-      index: "gsi4pk-gsi4sk-index",
-      pk: {
-        composite: ["repoOwner", "repoName", "ticketNumber"],
-        field: "gsi4pk"
-      },
-      sk: {
-        composite: [],
-        field: "gsi4sk"
-      }
-    }
-  }
-});
-
-const pullRequestComments = new Entity({
-  model: {
-    entity: "pullRequestComment",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    repoName: {
-      type: "string"
-    },
-    username: {
-      type: "string"
-    },
-    repoOwner: {
-      type: "string"
-    },
-    pullRequestNumber: {
-      type: "string"
-    },
-    commentId: {
-      type: "string"
-    },
-    replyTo: {
-      type: "string"
-    },
-    replyViewed: {
-      type: "string",
-      default: NotYetViewed,
-      get: (replyViewed) => {
-        return replyViewed !== NotYetViewed
-          ? replyViewed
-          : undefined;
-      },
-      set: (replyViewed) => {
-        if (replyViewed === undefined) {
-          return NotYetViewed;
-        }
-        return replyViewed;
-      }
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-      type: "string",
-      watch: "*",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-  },
-  indexes: {
-    comments: {
-      collection: "PRReview",
-      pk: {
-        composite: ["repoOwner", "repoName", "pullRequestNumber"],
-        field: "pk"
-      },
-      sk: {
-        composite: ["commentId"],
-        field: "sk"
-      }
-    },
-    created: {
-      collection: "conversations",
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        field: "gsi1pk",
-        composite: ["username"]
-      },
-      sk: {
-        field: "gsi1sk",
-        composite: ["repoOwner", "repoName"]
-      }
-    },
-    replies: {
-      collection: "inbox",
-      index: "gsi2pk-gsi2sk-index",
-      pk: {
-        composite: ["replyTo"],
-        field: "gsi2pk"
-      },
-      sk: {
-        composite: ["updatedAt", "replyViewed"],
-        field: "gsi2sk"
-      }
-    },
-  }
-});
-
-const repositories = new Entity({
-  model: {
-    entity: "repositories",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    repoName: {
-      type: "string"
-    },
-    repoOwner: {
-      type: "string"
-    },
-    about: {
-      type: "string"
-    },
-    username: {
-      type: "string",
-      readOnly: true,
-      watch: ["repoOwner"],
-      set: (_, {repoOwner}) => repoOwner
-    },
-    description: {
-      type: "string"
-    },
-    isPrivate: {
-      type: "boolean"
-    },
-    license: {
-      type: ["apache-2.0", "mit", "none"] as const,
-      default: "none"
-    },
-    defaultBranch: {
-      type: "string",
-      default: "main"
-    },
-    topics: {
-      type: "set",
-      items: "string"
-    },
-    followers: {
-      type: "set",
-      items: "string"
-    },
-    stars: {
-      type: "set",
-      items: "string"
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-      type: "string",
-      watch: "*",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-  },
-  indexes: {
-    repositories: {
-      collection: "alerts",
-      pk: {
-        composite: ["repoOwner"],
-        field: "pk"
-      },
-      sk: {
-        composite: ["repoName"],
-        field: "sk"
-      }
-    },
-    created: {
-      collection: "owned",
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        composite: ["username"],
-        field: "gsi1pk"
-      },
-      sk: {
-        composite: ["isPrivate", "createdAt"],
-        field: "gsi1sk"
-      }
-    },
-  }
-});
-
-const subscriptions = new Entity({
-    model: {
-        entity: "subscription",
-        service: "versioncontrol",
-        version: "1"
-    },
-    attributes: {
-        repoName: {
-            type: "string",
-            required: true,
-        },
-        repoOwner: {
-            type: "string",
-            required: true,
-        },
-        username: {
-            type: "string",
-            required: true,
-        },
-        ticketNumber: {
-            type: "string",
-            default: () => IsNotTicket,
-            set: (ticketNumber) => {
-                if (ticketNumber === IsNotTicket) {
-                    return "";
-                } else {
-                    return ticketNumber;
-                }
-            },
-            get: (ticketNumber) => {
-                if (ticketNumber === "") {
-                    return IsNotTicket;
-                } else {
-                    return ticketNumber;
-                }
-            }
-        },
-        ticketType: {
-            type: TicketTypes,
-            default: () => IsNotTicket,
-            set: (ticketType) => {
-              return ticketType === IsNotTicket
-                ? "#"
-                : ticketType;
-            },
-            get: (ticketType) => {
-                if (ticketType === "") {
-                    return IsNotTicket;
-                } else {
-                    return ticketType;
-                }
-            }
-        },
-        createdAt: {
-            type: "string",
-            set: () => new Date().toISOString().split('T')[0],
-            readOnly: true,
-        },
-        updatedAt: {
-            type: "string",
-            watch: "*",
-            set: () => new Date().toISOString().split('T')[0],
-            readOnly: true,
-        },
-    },
-    indexes: {
-        repository: {
-            pk: {
-                composite: ["repoOwner", "repoName"],
-                field: "pk"
-            },
-            sk: {
-                composite: ["username", "ticketType", "ticketNumber"],
-                field: "sk"
-            }
-        },
-        user: {
-            collection: "watching",
-            index: "gsi3pk-gsi3sk-index",
-            pk: {
-                composite: ["username"],
-                field: "gsi3pk"
-            },
-            sk: {
-                composite: ["ticketType", "ticketNumber"],
-                field: "gsi3sk"
-            }
-        },
-        tickets: {
-            collection: "subscribers",
-            index: "gsi4pk-gsi4sk-index",
-            pk: {
-                composite: ["repoOwner", "repoName", "ticketNumber"],
-                field: "gsi4pk"
-            },
-            sk: {
-                composite: ["ticketType", "username"],
-                field: "gsi4sk"
-            }
-        }
-    }
-});
-
-const users = new Entity({
-  model: {
-    entity: "user",
-    service: "versioncontrol",
-    version: "1"
-  },
-  attributes: {
-    username: {
-      type: "string"
-    },
-    fullName: {
-      type: "string"
-    },
-    photo: {
-      type: "string"
-    },
-    bio: {
-      type: "string"
-    },
-    location: {
-      type: "string"
-    },
-    pinned: {
-      type: "any"
-    },
-    following: {
-      type: "set",
-      items: "string"
-    },
-    followers: {
-      type: "set",
-      items: "string"
-    },
-    createdAt: {
-      type: "string",
-      set: () => new Date().toISOString().split('T')[0],
-      readOnly: true,
-    },
-    updatedAt: {
-        type: "string",
-        watch: "*",
-        set: () => new Date().toISOString().split('T')[0],
-        readOnly: true,
-    },
-  },
-  indexes: {
-    user: {
-      collection: "overview",
-      pk: {
-        composite: ["username"],
-        field: "pk"
-      },
-      sk: {
-        composite: [],
-        field: "sk"
-      }
-    },
-    _: {
-      collection: "owned",
-      index: "gsi1pk-gsi1sk-index",
-      pk: {
-        composite: ["username"],
-        field: "gsi1pk"
-      },
-      sk: {
-        field: "gsi1sk",
-        composite: []
-      }
-    },
-    subscriptions: {
-      collection: "watching",
-      index: "gsi3pk-gsi3sk-index",
-      pk: {
-        composite: ["username"],
-        field: "gsi3pk"
-      },
-      sk: {
-        composite: [],
-        field: "gsi3sk"
-      }
-    }
-  }
-});
-
-const versioncontrol = new Service({
-  users,
-  issues,
-  repositories,
-  pullRequests,
-  subscriptions,
-  issueComments,
-  pullRequestComments,
-}, {table: "your_table_name"});
-
-type IssueIds = Parameters<typeof issues.get>[0][0];
-type IssueCommentIds = Parameters<typeof issueComments.get>[0][0];
-type PullRequestIds = Parameters<typeof pullRequests.get>[0][0];
-type PullRequestCommentIds = Parameters<typeof pullRequestComments.get>[0][0];
-type OwnedItems = CollectionItem<typeof versioncontrol, "owned">;
-
-function isIssueCommentIds(comment: any): comment is IssueCommentIds {
-    return comment.issueNumber !== undefined && comment.username !== undefined;
-}
-
-function isPullRequestCommentIds(comment: any): comment is PullRequestCommentIds {
-    return comment.pullRequestNumber !== undefined && comment.username !== undefined;
-}
-
-// Get Public Repositories By Username
-async function getPublicRepository(username: string) {
-    return versioncontrol.entities.repositories.query.created({username, isPrivate: false});
-}
-
-// Get PullRequest and Associated Comments -- newest comments first
-async function reviewPullRequest(pr: PullRequestIds) {
-    return versioncontrol.collections.PRReview(pr)
-        .page(null, {params: {ScanIndexForward: false}})
-}
-
-// Get Issue and Associated Comments -- newest comments first
-async function reviewIssue(issue: IssueIds) {
-    return versioncontrol.collections.issueReview(issue).go({params: {ScanIndexForward: false}});
-}
-
-// Get PullRequests Created By User
-async function getUserPullRequests(username: string, status: Status = "") {
-    return versioncontrol.entities.pullRequests
-        .query.created({username, status})
-        .go({params: {ScanIndexForward: false}});
-}
-
-// Close pull request -- guards: can only be performed by user who opened PR or the repo owner
-async function closePullRequest(user: string, pr: PullRequestIds) {
-    return versioncontrol.entities.pullRequests
-        .update(pr)
-        .set({status: "Closed"})
-        .where(({username, repoOwner}, {eq}) => `
-            ${eq(username, user)} OR ${eq(repoOwner, user)}
-        `)
-        .go()
-}
-
-// Get all user info, repos, pull requests, and issues in one query
-async function getFirstPageLoad(username: string) {
-    const results: OwnedItems = {
-        issues: [],
-        pullRequests: [],
-        repositories: [],
-        users: [],
-    };
-
-    let page = null;
-
-    do {
-        const [next, data] = await versioncontrol.collections.owned({username}).page();
-        results.issues = results.issues.concat(data.issues);
-        results.pullRequests = results.pullRequests.concat(data.pullRequests);
-        results.repositories = results.repositories.concat(data.repositories);
-        results.users = results.users.concat(data.users);
-        page = next;
-    } while (page !== null);
-
-    return results;
-}
-
-// Get Subscriptions for a given Repository, PullRequest, or Issue.
-async function getSubscribed(repoOwner: string, repoName: string, ticketNumber: string = IsNotTicket) {
-    return versioncontrol.collections.subscribers({repoOwner, repoName, ticketNumber}).go();
-}
-
-const MinDate = "0000-00-00";
-const MaxDate = "9999-99-99";
-
-// Get unread comment replies
-async function getUnreadComments(user: string) {
-    const start = {
-        createdAt: MinDate,
-        replyViewed: NotYetViewed
-    };
-    const end = {
-        createdAt: MaxDate,
-        replyViewed: NotYetViewed
-    };
-    let [issues, pullRequests] = await Promise.all([
-        versioncontrol.entities
-            .issueComments.query
-            .replies({replyTo: user})
-            .between(start, end)
-            .go(),
-
-        versioncontrol.entities
-            .pullRequestComments.query
-            .replies({replyTo: user})
-            .between(start, end)
-            .go()
-    ]);
-
-    return {
-        issues,
-        pullRequests
-    };
-}
-
-// Mark comment reply as read -- guards: can only be done by the user who was being replied to
-async function readReply(user: string, comment: IssueCommentIds): Promise<boolean>;
-async function readReply(user: string, comment: PullRequestCommentIds): Promise<boolean>;
-async function readReply(user: string, comment: any): Promise<boolean> {
-    const replyViewed = new Date().toISOString().split('T')[0];
-    if (isIssueCommentIds(comment)) {
-        return await versioncontrol.entities.issueComments
-            .patch(comment)
-            .set({replyViewed})
-            .where(({replyTo}, {eq}) => eq(replyTo, user))
-            .go()
-            .then(() => true)
-            .catch(() => false);
-    } else if (isPullRequestCommentIds(comment)) {
-        return await versioncontrol.entities.pullRequestComments
-            .patch(comment)
-            .set({replyViewed})
-            .where(({replyTo}, {eq}) => eq(replyTo, user))
-            .go()
-            .then(() => true)
-            .catch(() => false);
-    } else {
-        return false;
-    }
-}
-
-async function approvePullRequest(repoOwner: string, repoName: string, pullRequestNumber: string, username: string) {
-    const pullRequest = await versioncontrol.entities.pullRequests
-        .get({repoOwner, repoName, pullRequestNumber})
-        .go();
-
-    if (!pullRequest || !pullRequest.reviewers) {
-        return false;
-    }
-
-    let index: number = -1;
-
-    for (let i = 0; i < pullRequest.reviewers.length; i++) {
-        const reviewer = pullRequest.reviewers[i];
-        if (reviewer.username === username) {
-            index = i;
-        }
-    }
-
-    if (index === -1) {
-        return false;
-    }
-
-    return versioncontrol.entities.pullRequests
-        .update({repoOwner, repoName, pullRequestNumber})
-        .data(({reviewers}, {set}) => {
-            set(reviewers[index].approved, true);
-        })
-        .where(({reviewers}, {eq}) => `
-            ${eq(reviewers[index].username, username)};
-        `)
-        .go()
-        .then(() => true)
-        .catch(() => false);
-}
-
-async function followRepository(repoOwner: string, repoName: string, follower: string) {
-    await versioncontrol.entities
-        .repositories.update({repoOwner, repoName})
-        .add({followers: [follower]})
-        .go()
-}
-
-// getPublicRepository("abc");
-reviewPullRequest({
-  pullRequestNumber: "110",
-  repoName: "electrodb",
-  repoOwner: "tywalch"
-});
-
-reviewIssue({
-  issueNumber: "281",
-  repoName: "electrodb",
-  repoOwner: "tywalch"
-});
-
-getUserPullRequests("tywalch");
-getUserPullRequests("tywalch", "Closed");
-
-closePullRequest("tywalch", {
-  pullRequestNumber: "301",
-  repoName: "electrodb",
-  repoOwner: "tywalch",
-});
-
-getFirstPageLoad("tywalch");
-getSubscribed
-getUnreadComments
-readReply
-readReply
-readReply
-approvePullRequest
-followRepository