@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha160

package/src/testutils/fake_data/const.ts

@@ -1,64 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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",
-});