electrodb 1.4.0 → 1.4.4

package/notes

@@ -1,31 +1,937 @@
-x validate field names work with complex types
-- validate that validation works with complex types
-- validate enum works with complex types?
-x build out response types for at least partial and null
-
-For Docs
-x enum strings must be marked `as const`
-x set properties on attributes must be typed with a `?:`
-- hidden attribute property disables `get`
-x update methods examples have changed
-x sets leverage arrays
-x default is applied before `required`
-x required cannot be removed
-- removing `cast` from documentation
-
-Needs implementing:
-x add cast: "list", "set" (maybe dont)
-x find usages of `.name` in errors etc and replace with `.path`
-x sets only allowed if client is present
-x No "removing" required attribute?
-x No "never" objects in update
-x does dynamodb accept empty objects/~arrays~/sets? if so, reconsider the behaviour to only call getters/setters if object/array not empty
-x Use client to make sets if it is passed!
-
-Questions
-    x What happens when you have a required attribute, but it has a default, and you try to put
-    x Is getReadOnly property only grabbing from top level?
-Thoughts
-x revisit thoughts on required, but with default, put implementation
+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