@snowtop/ent 0.1.0-alpha160-test4 → 0.1.0-alpha160-test6

package/src/testutils/fake_data/const.ts

@@ -0,0 +1,64 @@
+import { Ent, LoadEntOptions } from "../../core/base";
+import { FakeContact, FakeEvent, FakeUser, FakeTag } from "./internal";
+
+export enum EdgeType {
+  UserToContacts = "userToContacts",
+  UserToFriends = "userToFriends",
+  UserToCustomEdge = "userToCustomEdge",
+
+  UserToEventsAttending = "userToEventsAttending",
+  EventToAttendees = "eventToAttendees",
+
+  // we may need the inverse edge of these 3 later
+  EventToInvited = "eventToInvited",
+  EventToDeclined = "eventToDeclined",
+  EventToMaybe = "eventToMaybe",
+
+  EventToHosts = "eventToHosts",
+  UserToHostedEvents = "userToHostedEvents",
+
+  UserToFriendRequests = "userToFriendRequests",
+  UserToIncomingFriendRequests = "userToIncomingFriendRequests",
+
+  // can follow users or events...
+  // so a polymorphic edge
+  UserToFollowing = "userToFollowing",
+  ObjectToFollowedUsers = "objectToFollowedUsers",
+}
+
+export enum NodeType {
+  FakeUser = "user",
+  FakeContact = "contact",
+  FakeEvent = "event",
+  FakeTag = "tag",
+}
+
+export const SymmetricEdges = new Set<string>();
+SymmetricEdges.add(EdgeType.UserToFriends);
+
+export const InverseEdges = new Map<EdgeType, EdgeType>([
+  [EdgeType.UserToEventsAttending, EdgeType.EventToAttendees],
+  [EdgeType.EventToAttendees, EdgeType.UserToEventsAttending],
+
+  [EdgeType.UserToHostedEvents, EdgeType.EventToHosts],
+  [EdgeType.EventToHosts, EdgeType.UserToHostedEvents],
+
+  [EdgeType.UserToFriendRequests, EdgeType.UserToIncomingFriendRequests],
+  [EdgeType.UserToIncomingFriendRequests, EdgeType.UserToFriendRequests],
+
+  [EdgeType.UserToFollowing, EdgeType.ObjectToFollowedUsers],
+  [EdgeType.ObjectToFollowedUsers, EdgeType.UserToFollowing],
+]);
+
+export function getLoaderOptions(type: NodeType): LoadEntOptions<Ent> {
+  switch (type) {
+    case NodeType.FakeContact:
+      return FakeContact.loaderOptions();
+    case NodeType.FakeUser:
+      return FakeUser.loaderOptions();
+    case NodeType.FakeEvent:
+      return FakeEvent.loaderOptions();
+    case NodeType.FakeTag:
+      return FakeTag.loaderOptions();
+  }
+}

package/src/testutils/fake_data/events_query.ts

@@ -0,0 +1,145 @@
+import { ID, Viewer } from "../../core/base";
+import { AssocEdge } from "../../core/ent";
+import {
+  AssocEdgeQueryBase,
+  EdgeQuerySource,
+} from "../../core/query/assoc_query";
+import { FakeUser } from "./fake_user";
+import { EdgeType, FakeEvent } from "./internal";
+import { AssocEdgeCountLoaderFactory } from "../../core/loaders/assoc_count_loader";
+import { AssocEdgeLoaderFactory } from "../../core/loaders/assoc_edge_loader";
+
+export class EventToAttendeesQuery extends AssocEdgeQueryBase<
+  FakeEvent,
+  FakeUser,
+  AssocEdge
+> {
+  constructor(viewer: Viewer, src: EdgeQuerySource<FakeEvent, FakeUser>) {
+    super(
+      viewer,
+      src,
+      new AssocEdgeCountLoaderFactory(EdgeType.EventToAttendees),
+      new AssocEdgeLoaderFactory(EdgeType.EventToAttendees, AssocEdge),
+      FakeUser.loaderOptions(),
+    );
+  }
+
+  static query(
+    viewer: Viewer,
+    src: EdgeQuerySource<FakeEvent, FakeUser>,
+  ): EventToAttendeesQuery {
+    return new EventToAttendeesQuery(viewer, src);
+  }
+
+  sourceEnt(id: ID) {
+    return FakeEvent.load(this.viewer, id);
+  }
+}
+
+export class EventToInvitedQuery extends AssocEdgeQueryBase<
+  FakeEvent,
+  FakeUser,
+  AssocEdge
+> {
+  constructor(viewer: Viewer, src: EdgeQuerySource<FakeEvent, FakeUser>) {
+    super(
+      viewer,
+      src,
+      new AssocEdgeCountLoaderFactory(EdgeType.EventToInvited),
+      new AssocEdgeLoaderFactory(EdgeType.EventToInvited, AssocEdge),
+      FakeUser.loaderOptions(),
+    );
+  }
+
+  static query(
+    viewer: Viewer,
+    src: EdgeQuerySource<FakeEvent, FakeUser>,
+  ): EventToInvitedQuery {
+    return new EventToInvitedQuery(viewer, src);
+  }
+
+  sourceEnt(id: ID) {
+    return FakeEvent.load(this.viewer, id);
+  }
+}
+
+export class EventToDeclinedQuery extends AssocEdgeQueryBase<
+  FakeEvent,
+  FakeUser,
+  AssocEdge
+> {
+  constructor(viewer: Viewer, src: EdgeQuerySource<FakeEvent, FakeUser>) {
+    super(
+      viewer,
+      src,
+      new AssocEdgeCountLoaderFactory(EdgeType.EventToDeclined),
+      new AssocEdgeLoaderFactory(EdgeType.EventToDeclined, AssocEdge),
+      FakeUser.loaderOptions(),
+    );
+  }
+
+  static query(
+    viewer: Viewer,
+    src: EdgeQuerySource<FakeEvent, FakeUser>,
+  ): EventToDeclinedQuery {
+    return new EventToDeclinedQuery(viewer, src);
+  }
+
+  sourceEnt(id: ID) {
+    return FakeEvent.load(this.viewer, id);
+  }
+}
+
+export class EventToMaybeQuery extends AssocEdgeQueryBase<
+  FakeEvent,
+  FakeUser,
+  AssocEdge
+> {
+  constructor(viewer: Viewer, src: EdgeQuerySource<FakeEvent, FakeUser>) {
+    super(
+      viewer,
+      src,
+      new AssocEdgeCountLoaderFactory(EdgeType.EventToMaybe),
+      new AssocEdgeLoaderFactory(EdgeType.EventToMaybe, AssocEdge),
+      FakeUser.loaderOptions(),
+    );
+  }
+
+  static query(
+    viewer: Viewer,
+    src: EdgeQuerySource<FakeEvent, FakeUser>,
+  ): EventToMaybeQuery {
+    return new EventToMaybeQuery(viewer, src);
+  }
+
+  sourceEnt(id: ID) {
+    return FakeEvent.load(this.viewer, id);
+  }
+}
+
+export class EventToHostsQuery extends AssocEdgeQueryBase<
+  FakeEvent,
+  FakeUser,
+  AssocEdge
+> {
+  constructor(viewer: Viewer, src: EdgeQuerySource<FakeEvent, FakeUser>) {
+    super(
+      viewer,
+      src,
+      new AssocEdgeCountLoaderFactory(EdgeType.EventToHosts),
+      new AssocEdgeLoaderFactory(EdgeType.EventToHosts, AssocEdge),
+      FakeUser.loaderOptions(),
+    );
+  }
+
+  static query(
+    viewer: Viewer,
+    src: EdgeQuerySource<FakeEvent, FakeUser>,
+  ): EventToHostsQuery {
+    return new EventToHostsQuery(viewer, src);
+  }
+
+  sourceEnt(id: ID) {
+    return FakeEvent.load(this.viewer, id);
+  }
+}

package/src/testutils/fake_data/fake_contact.ts

@@ -0,0 +1,150 @@
+import {
+  ID,
+  Ent,
+  Viewer,
+  Data,
+  LoadEntOptions,
+  PrivacyPolicy,
+  Context,
+} from "../../core/base";
+import { loadEnt, loadEntX } from "../../core/ent";
+import { AllowIfViewerIsRule, AlwaysDenyRule } from "../../core/privacy";
+import { getBuilderSchemaFromFields, SimpleBuilder } from "../builder";
+import { StringType, UUIDType } from "../../schema";
+import { NodeType } from "./const";
+import { table, uuid, text, timestamptz } from "../db/temp_db";
+import { ObjectLoaderFactory } from "../../core/loaders";
+import { convertDate } from "../../core/convert";
+import { WriteOperation } from "../../action";
+
+export class FakeContact implements Ent {
+  readonly id: ID;
+  readonly data: Data;
+  readonly nodeType = NodeType.FakeContact;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly firstName: string;
+  readonly lastName: string;
+  readonly emailAddress: string;
+  readonly userID: ID;
+
+  getPrivacyPolicy(): PrivacyPolicy<this> {
+    return {
+      rules: [new AllowIfViewerIsRule("userID"), AlwaysDenyRule],
+    };
+  }
+
+  constructor(public viewer: Viewer, data: Data) {
+    this.data = data;
+    this.id = data.id;
+    this.createdAt = convertDate(data.created_at);
+    this.updatedAt = convertDate(data.updated_at);
+    this.firstName = data.first_name;
+    this.lastName = data.last_name;
+    this.emailAddress = data.email_address;
+    this.userID = data.user_id;
+  }
+
+  __setRawDBData(data: Data) {}
+
+  static getFields(): string[] {
+    return [
+      "id",
+      "created_at",
+      "updated_at",
+      "first_name",
+      "last_name",
+      "email_address",
+      "user_id",
+    ];
+  }
+
+  static getTestTable() {
+    return table(
+      "fake_contacts",
+      uuid("id", { primaryKey: true }),
+      timestamptz("created_at"),
+      timestamptz("updated_at"),
+      text("first_name"),
+      text("last_name"),
+      text("email_address"),
+      uuid("user_id"),
+    );
+  }
+
+  static loaderOptions(): LoadEntOptions<FakeContact> {
+    return {
+      tableName: "fake_contacts",
+      fields: FakeContact.getFields(),
+      ent: this,
+      loaderFactory: new ObjectLoaderFactory({
+        tableName: "fake_contacts",
+        key: "id",
+        fields: FakeContact.getFields(),
+      }),
+    };
+  }
+  static async load(v: Viewer, id: ID): Promise<FakeContact | null> {
+    return loadEnt(v, id, FakeContact.loaderOptions());
+  }
+
+  static async loadX(v: Viewer, id: ID): Promise<FakeContact> {
+    return loadEntX(v, id, FakeContact.loaderOptions());
+  }
+
+  static async loadRawData(id: ID, context?: Context): Promise<Data | null> {
+    return FakeContact.loaderOptions()
+      .loaderFactory.createLoader(context)
+      .load(id);
+  }
+}
+
+export const FakeContactSchema = getBuilderSchemaFromFields(
+  {
+    firstName: StringType(),
+    lastName: StringType(),
+    emailAddress: StringType(),
+    userID: UUIDType({
+      foreignKey: { schema: "User", column: "ID" },
+    }),
+  },
+  FakeContact,
+);
+
+export interface ContactCreateInput {
+  firstName: string;
+  lastName: string;
+  emailAddress: string;
+  userID: ID;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export function getContactBuilder(viewer: Viewer, input: ContactCreateInput) {
+  const m = new Map();
+  for (const key in input) {
+    m.set(key, input[key]);
+  }
+  //To lock in the value of Date now incase of advanceTo/advanceBy
+  m.set("createdAt", new Date());
+  m.set("updatedAt", new Date());
+
+  return new SimpleBuilder(
+    viewer,
+    FakeContactSchema,
+    m,
+    WriteOperation.Insert,
+    null,
+  );
+}
+
+export async function createContact(viewer: Viewer, input: ContactCreateInput) {
+  const builder = getContactBuilder(viewer, input);
+  return await builder.saveX();
+}
+
+export const contactLoader = new ObjectLoaderFactory({
+  tableName: "fake_contacts",
+  fields: FakeContact.getFields(),
+  key: "id",
+});

package/src/testutils/fake_data/fake_event.ts

@@ -0,0 +1,150 @@
+import {
+  ID,
+  Ent,
+  Viewer,
+  Data,
+  LoadEntOptions,
+  PrivacyPolicy,
+} from "../../core/base";
+import { loadEnt, loadEntX } from "../../core/ent";
+import { AlwaysAllowPrivacyPolicy } from "../../core/privacy";
+import { getBuilderSchemaFromFields, SimpleBuilder } from "../builder";
+import { StringType, UUIDType, TimestampType } from "../../schema";
+import { NodeType } from "./const";
+import { table, uuid, text, timestamptz } from "../db/temp_db";
+import { ObjectLoaderFactory } from "../../core/loaders";
+import { convertDate, convertNullableDate } from "../../core/convert";
+import { WriteOperation } from "../../action";
+
+export class FakeEvent implements Ent {
+  readonly id: ID;
+  readonly data: Data;
+  readonly nodeType = NodeType.FakeEvent;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly startTime: Date;
+  readonly endTime: Date | null;
+  readonly location: string;
+  readonly title: string;
+  readonly description: string | null;
+  readonly userID: ID;
+
+  getPrivacyPolicy(): PrivacyPolicy<this> {
+    return AlwaysAllowPrivacyPolicy;
+  }
+
+  constructor(public viewer: Viewer, data: Data) {
+    this.data = data;
+    this.id = data.id;
+    this.createdAt = convertDate(data.created_at);
+    this.updatedAt = convertDate(data.updated_at);
+    this.startTime = convertDate(data.start_time);
+    this.endTime = convertNullableDate(data.end_time);
+    this.location = data.location;
+    this.title = data.title;
+    this.description = data.description;
+    this.userID = data.user_id;
+  }
+
+  __setRawDBData(data: Data) {}
+
+  private static getFields(): string[] {
+    return [
+      "id",
+      "created_at",
+      "updated_at",
+      "start_time",
+      "end_time",
+      "location",
+      "title",
+      "description",
+      "user_id",
+    ];
+  }
+
+  static getTestTable() {
+    return table(
+      "fake_events",
+      uuid("id", { primaryKey: true }),
+      timestamptz("created_at"),
+      timestamptz("updated_at"),
+      // TODO index:true
+      timestamptz("start_time"),
+      timestamptz("end_time", { nullable: true }),
+      text("location"),
+      text("title"),
+      text("description", { nullable: true }),
+      uuid("user_id"),
+    );
+  }
+
+  static loaderOptions(): LoadEntOptions<FakeEvent> {
+    return {
+      tableName: "fake_events",
+      fields: FakeEvent.getFields(),
+      ent: this,
+      loaderFactory: new ObjectLoaderFactory({
+        tableName: "fake_events",
+        key: "id",
+        fields: FakeEvent.getFields(),
+      }),
+    };
+  }
+  static async load(v: Viewer, id: ID): Promise<FakeEvent | null> {
+    return loadEnt(v, id, FakeEvent.loaderOptions());
+  }
+
+  static async loadX(v: Viewer, id: ID): Promise<FakeEvent> {
+    return loadEntX(v, id, FakeEvent.loaderOptions());
+  }
+}
+
+export const FakeEventSchema = getBuilderSchemaFromFields(
+  {
+    startTime: TimestampType({
+      index: true,
+    }),
+    endTime: TimestampType({
+      nullable: true,
+    }),
+    title: StringType(),
+    location: StringType(),
+    description: StringType({
+      nullable: true,
+    }),
+    userID: UUIDType({
+      foreignKey: { schema: "User", column: "ID" },
+    }),
+  },
+  FakeEvent,
+);
+
+export interface EventCreateInput {
+  createdAt?: Date;
+  updatedAt?: Date;
+  startTime: Date;
+  endTime?: Date | null;
+  location: string;
+  title: string;
+  description?: string | null;
+  userID: ID;
+}
+
+export function getEventBuilder(viewer: Viewer, input: EventCreateInput) {
+  const m = new Map();
+  for (const key in input) {
+    m.set(key, input[key]);
+  }
+  return new SimpleBuilder(
+    viewer,
+    FakeEventSchema,
+    m,
+    WriteOperation.Insert,
+    null,
+  );
+}
+
+export async function createEvent(viewer: Viewer, input: EventCreateInput) {
+  const builder = getEventBuilder(viewer, input);
+  return await builder.saveX();
+}

package/src/testutils/fake_data/fake_tag.ts

@@ -0,0 +1,139 @@
+import {
+  ID,
+  Ent,
+  Viewer,
+  Data,
+  LoadEntOptions,
+  PrivacyPolicy,
+} from "../../core/base";
+import { loadEnt, loadEntX } from "../../core/ent";
+import {
+  AlwaysDenyRule,
+  AllowIfViewerIsEntPropertyRule,
+} from "../../core/privacy";
+import { getBuilderSchemaFromFields, SimpleAction } from "../builder";
+import { StringType, UUIDType } from "../../schema";
+import { NodeType } from "./const";
+import { table, uuid, text, timestamptz, index } from "../db/temp_db";
+import { ObjectLoaderFactory } from "../../core/loaders";
+import { convertDate } from "../../core/convert";
+import { WriteOperation } from "../../action";
+
+export class FakeTag implements Ent {
+  readonly id: ID;
+  readonly data: Data;
+  readonly nodeType = NodeType.FakeUser;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly displayName: string;
+  readonly canonicalName: string;
+  readonly ownerID: string;
+
+  getPrivacyPolicy(): PrivacyPolicy<this> {
+    return {
+      rules: [new AllowIfViewerIsEntPropertyRule("ownerID"), AlwaysDenyRule],
+    };
+  }
+
+  constructor(public viewer: Viewer, data: Data) {
+    this.data = data;
+    this.id = data.id;
+    this.createdAt = convertDate(data.created_at);
+    this.updatedAt = convertDate(data.updated_at);
+    this.displayName = data.display_name;
+    this.canonicalName = data.canonical_name;
+    this.ownerID = data.owner_id;
+  }
+
+  __setRawDBData(data: Data) {}
+
+  static getFields(): string[] {
+    return [
+      "id",
+      "created_at",
+      "updated_at",
+      "display_name",
+      "canonical_name",
+      "owner_id",
+    ];
+  }
+
+  static getTestTable() {
+    return table(
+      "fake_tags",
+      uuid("id", { primaryKey: true }),
+      timestamptz("created_at"),
+      timestamptz("updated_at"),
+      text("display_name"),
+      text("canonical_name"),
+      uuid("owner_id"), // TODO index: true sqlite broken?
+      index("fake_tags", ["canonical_name", "owner_id"], { unique: true }),
+    );
+  }
+
+  static loaderOptions(): LoadEntOptions<FakeTag> {
+    return {
+      tableName: "fake_tags",
+      fields: FakeTag.getFields(),
+      ent: this,
+      loaderFactory: tagLoader,
+    };
+  }
+  static async load(v: Viewer, id: ID): Promise<FakeTag | null> {
+    return loadEnt(v, id, FakeTag.loaderOptions());
+  }
+
+  static async loadX(v: Viewer, id: ID): Promise<FakeTag> {
+    return loadEntX(v, id, FakeTag.loaderOptions());
+  }
+}
+
+export const FakeTagSchema = getBuilderSchemaFromFields(
+  {
+    displayName: StringType(),
+    canonicalName: StringType().trim().toLowerCase(),
+    ownerID: UUIDType({}),
+  },
+  FakeTag,
+);
+
+export interface TagCreateInput {
+  displayName: string;
+  canonicalName: string;
+  ownerID: ID;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export type TagEditInput = Partial<TagCreateInput>;
+
+export function getTagBuilder(viewer: Viewer, input: TagCreateInput) {
+  const action = getTagAction(viewer, input);
+  return action.builder;
+}
+
+export function getTagAction(viewer: Viewer, input: TagCreateInput) {
+  const m = new Map();
+  for (const key in input) {
+    m.set(key, input[key]);
+  }
+  const action = new SimpleAction(
+    viewer,
+    FakeTagSchema,
+    m,
+    WriteOperation.Insert,
+    null,
+  );
+  return action;
+}
+
+export async function createTag(viewer: Viewer, input: TagCreateInput) {
+  const action = getTagAction(viewer, input);
+  return action.saveX();
+}
+
+export const tagLoader = new ObjectLoaderFactory({
+  tableName: "fake_tags",
+  fields: FakeTag.getFields(),
+  key: "id",
+});