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

package/src/testutils/builder.ts

@@ -0,0 +1,422 @@
+import {
+  Ent,
+  ID,
+  Viewer,
+  Data,
+  EntConstructor,
+  PrivacyPolicy,
+} from "../core/base";
+import { AlwaysAllowPrivacyPolicy } from "../core/privacy";
+import { Orchestrator } from "../action/orchestrator";
+import {
+  Action,
+  Builder,
+  Changeset,
+  WriteOperation,
+  Validator,
+  Trigger,
+  saveBuilder,
+  saveBuilderX,
+  Observer,
+} from "../action";
+import { getFields, getFieldsWithPrivacy, FieldMap, Schema } from "../schema";
+import { QueryRecorder } from "./db_mock";
+import pluralize from "pluralize";
+import { snakeCase } from "snake-case";
+import { ObjectLoaderFactory } from "../core/loaders";
+import { convertDate } from "../core/convert";
+import { camelCase } from "camel-case";
+import {
+  SchemaConfig,
+  EntSchema,
+  EntSchemaWithTZ,
+} from "../schema/base_schema";
+import { FieldInfoMap, getStorageKey } from "../schema/schema";
+import { Clause } from "src/core/clause";
+import { ChangesetOptions } from "../action/action";
+
+export class BaseEnt {
+  readonly id: ID;
+
+  constructor(public viewer: Viewer, public readonly data: Data) {
+    this.data.created_at = convertDate(data.created_at);
+    this.data.updated_at = convertDate(data.updated_at);
+    this.id = data[this.getKey()];
+  }
+
+  getKey() {
+    return "id";
+  }
+
+  getPrivacyPolicy(): PrivacyPolicy {
+    return AlwaysAllowPrivacyPolicy;
+  }
+  __setRawDBData(data: Data) {
+    // doesn't apply here so ignore...
+  }
+}
+
+export class User extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "User";
+  firstName: string;
+
+  constructor(public viewer: Viewer, public data: Data) {
+    super(viewer, data);
+    this.firstName = data.first_name;
+  }
+}
+
+export class Event extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "Event";
+}
+
+export class Contact extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "Contact";
+  getPrivacyPolicy(): PrivacyPolicy<this> {
+    return AlwaysAllowPrivacyPolicy;
+  }
+}
+
+export class Group extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "Group";
+  getPrivacyPolicy(): PrivacyPolicy<this> {
+    return AlwaysAllowPrivacyPolicy;
+  }
+}
+
+export class Message extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "Message";
+}
+
+export class Address extends BaseEnt implements Ent {
+  accountID: string = "";
+  nodeType = "Address";
+}
+
+export interface BuilderSchema<T extends Ent> extends Schema {
+  ent: EntConstructor<T>;
+}
+
+export class EntBuilderSchema<T extends Ent> extends EntSchema {
+  constructor(public ent: EntConstructor<T>, cfg: SchemaConfig) {
+    super(cfg);
+  }
+}
+
+export function getBuilderSchema<T extends Ent>(
+  cfg: SchemaConfig,
+  ent: EntConstructor<T>,
+): BuilderSchema<T> {
+  return {
+    ...new EntSchema(cfg),
+    ent,
+  };
+}
+
+export function getBuilderSchemaFromFields<T extends Ent>(
+  fields: FieldMap,
+  ent: EntConstructor<T>,
+  opts?: Partial<Exclude<SchemaConfig, "fields">>,
+): BuilderSchema<T> {
+  return {
+    ...new EntSchema({ ...opts, fields }),
+    ent,
+  };
+}
+
+export function getBuilderSchemaTZFromFields<T extends Ent>(
+  fields: FieldMap,
+  ent: EntConstructor<T>,
+): BuilderSchema<T> {
+  return {
+    ...new EntSchemaWithTZ({ fields }),
+    ent,
+  };
+}
+
+export function getSchemaName(value: BuilderSchema<Ent>) {
+  return value.ent.name;
+}
+
+export function getTableName(value: BuilderSchema<Ent>) {
+  return pluralize(snakeCase(value.ent.name)).toLowerCase();
+}
+
+function randomNum(): string {
+  return Math.random().toString(10).substring(2);
+}
+
+export function getFieldInfo(value: BuilderSchema<Ent>) {
+  const fields = getFields(value);
+  let ret: FieldInfoMap = {};
+  for (const [k, f] of fields) {
+    ret[k] = {
+      dbCol: getStorageKey(f, k),
+      // in tests (anything using SimpleBuilder), make it be the same as the fieldName
+      inputKey: k,
+    };
+  }
+  return ret;
+}
+
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+
+// reuses orchestrator and standard things
+export class SimpleBuilder<
+  T extends Ent,
+  TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>,
+> implements Builder<T, Viewer, TExistingEnt>
+{
+  ent: EntConstructor<T, Viewer>;
+  placeholderID: ID;
+  public orchestrator: Orchestrator<T, Data, Viewer, TExistingEnt>;
+  public fields: Map<string, any>;
+  nodeType: string;
+  m: Map<string, any> = new Map();
+
+  constructor(
+    public viewer: Viewer,
+    private schema: BuilderSchema<T>,
+    fields: Map<string, any>,
+    public operation: WriteOperation = WriteOperation.Insert,
+    public existingEnt: TExistingEnt,
+    action?:
+      | Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt>
+      | undefined,
+    expressions?: Map<string, Clause>,
+  ) {
+    // create dynamic placeholder
+    // TODO: do we need to use this as the node when there's an existingEnt
+    // same for generated builders.
+    this.placeholderID = `$ent.idPlaceholderID$ ${randomNum()}-${
+      schema.ent?.name
+    }`;
+
+    if (this.operation === WriteOperation.Insert) {
+      for (const [key, value] of fields) {
+        if (key === "id" && value === "{id}") {
+          fields.set(key, QueryRecorder.newID());
+        }
+      }
+    }
+    this.fields = fields;
+
+    const schemaFields = getFields(schema);
+    let key = "id";
+    if (!schemaFields.has("id") && !schemaFields.has("ID")) {
+      if (schemaFields.size !== 1) {
+        throw new Error(
+          `no id field and multiple fields so can't deduce key. add an id field to schema`,
+        );
+      }
+      for (const [name, _] of fields) {
+        key = snakeCase(name);
+      }
+    }
+    this.ent = schema.ent;
+    const tableName = getTableName(schema);
+    this.nodeType = camelCase(schema.ent.name);
+    const fieldInfo = getFieldInfo(schema);
+    this.orchestrator = new Orchestrator<T, Data, Viewer, TExistingEnt>({
+      viewer: this.viewer,
+      operation: operation,
+      tableName: tableName,
+      key,
+      fieldInfo,
+      loaderOptions: {
+        loaderFactory: new ObjectLoaderFactory({
+          tableName: tableName,
+          fields: [],
+          key,
+        }),
+        ent: schema.ent,
+        tableName: tableName,
+        fields: [],
+        fieldPrivacy: getFieldsWithPrivacy(schema, fieldInfo),
+      },
+      builder: this,
+      action: action,
+      expressions,
+      schema: this.schema,
+      editedFields: () => {
+        // to simulate what we do in generated builders where we return a new Map
+        const m = new Map();
+        for (const [k, v] of this.fields) {
+          m.set(k, v);
+        }
+        return m;
+      },
+      updateInput: this.updateInput.bind(this),
+    });
+  }
+
+  getInput(): Data {
+    let ret: Data = {};
+    for (const [k, v] of this.fields) {
+      ret[k] = v;
+    }
+    return ret;
+  }
+  updateInput(input: Data) {
+    const knownFields = getFields(this.schema);
+    for (const k in input) {
+      if (knownFields.has(k)) {
+        this.fields.set(k, input[k]);
+      } else {
+        // related to #510. we do camelCase to pass fields in here but fields may be snakeCase and we want that to pass in tests
+        // we do camelCase in
+        const sc = snakeCase(k);
+        if (knownFields.has(sc)) {
+          this.fields.set(sc, input[k]);
+        }
+      }
+    }
+  }
+
+  // store data in Builder that can be retrieved by another validator, trigger, observer later in the action
+  storeData(k: string, v: any) {
+    this.m.set(k, v);
+  }
+
+  // retrieve data stored in this Builder with key
+  getStoredData(k: string) {
+    return this.m.get(k);
+  }
+
+  build(): Promise<Changeset> {
+    return this.orchestrator.build();
+  }
+
+  buildWithOptions_BETA(options: ChangesetOptions): Promise<Changeset> {
+    return this.orchestrator.buildWithOptions_BETA(options);
+  }
+
+  async editedEnt(): Promise<T | null> {
+    return await this.orchestrator.editedEnt();
+  }
+
+  async editedEntX(): Promise<T> {
+    return await this.orchestrator.editedEntX();
+  }
+
+  async save(): Promise<void> {
+    await saveBuilder(this);
+  }
+
+  async saveX(): Promise<void> {
+    await saveBuilderX(this);
+  }
+
+  async valid(): Promise<boolean> {
+    return await this.orchestrator.valid();
+  }
+
+  async validX(): Promise<void> {
+    return await this.orchestrator.validX();
+  }
+}
+
+interface viewerEntLoadFunc {
+  (data: Data): Viewer | Promise<Viewer>;
+}
+
+export class SimpleAction<
+  T extends Ent,
+  TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>,
+> implements
+    Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt>
+{
+  builder: SimpleBuilder<T, TExistingEnt>;
+  viewerForEntLoad: viewerEntLoadFunc | undefined;
+
+  constructor(
+    public viewer: Viewer,
+    schema: BuilderSchema<T>,
+    private fields: Map<string, any>,
+    operation: WriteOperation = WriteOperation.Insert,
+    existingEnt: TExistingEnt,
+    expressions?: Map<string, Clause>,
+  ) {
+    this.builder = new SimpleBuilder<T, TExistingEnt>(
+      this.viewer,
+      schema,
+      fields,
+      operation,
+      existingEnt,
+      this,
+      expressions,
+    );
+  }
+
+  getTriggers():
+    | (Trigger<T, SimpleBuilder<T>> | Array<Trigger<T, SimpleBuilder<T>>>)[] {
+    return [];
+  }
+
+  getValidators(): Validator<T, SimpleBuilder<T>>[] {
+    return [];
+  }
+
+  getObservers(): Observer<T, SimpleBuilder<T>>[] {
+    return [];
+  }
+
+  getPrivacyPolicy() {
+    return AlwaysAllowPrivacyPolicy;
+  }
+
+  getInput() {
+    const ret: Data = {};
+    for (const [k, v] of this.fields) {
+      ret[k] = v;
+    }
+    return ret;
+  }
+
+  changeset(): Promise<Changeset> {
+    return this.builder.build();
+  }
+
+  changesetWithOptions_BETA(options: ChangesetOptions): Promise<Changeset> {
+    return this.builder.buildWithOptions_BETA(options);
+  }
+
+  valid(): Promise<boolean> {
+    return this.builder.orchestrator.valid();
+  }
+
+  validX(): Promise<void> {
+    return this.builder.orchestrator.validX();
+  }
+
+  validWithErrors() {
+    return this.builder.orchestrator.validWithErrors();
+  }
+
+  async save(): Promise<T | null> {
+    await saveBuilder(this.builder);
+    if (this.builder.operation !== WriteOperation.Delete) {
+      return this.builder.orchestrator.editedEnt();
+    }
+    return null;
+  }
+
+  async saveX(): Promise<T> {
+    await saveBuilderX(this.builder);
+    return this.builder.orchestrator.editedEntX();
+  }
+
+  async editedEnt(): Promise<T | null> {
+    return this.builder.orchestrator.editedEnt();
+  }
+
+  async editedEntX(): Promise<T> {
+    return this.builder.orchestrator.editedEntX();
+  }
+}

package/src/testutils/context/test_context.ts

@@ -0,0 +1,25 @@
+import { Context, Viewer } from "../../core/base";
+import { ContextCache } from "../../core/context";
+import { LoggedOutViewer } from "../../core/viewer";
+
+interface viewerWithContext extends Viewer {
+  setContext(ctx: Context): any;
+}
+
+export class TestContext implements Context {
+  constructor(viewer?: Viewer) {
+    if (viewer) {
+      this.viewer = viewer;
+      if ((viewer as viewerWithContext).setContext !== undefined) {
+        (viewer as viewerWithContext).setContext(this);
+      }
+    }
+  }
+
+  cache: ContextCache = new ContextCache();
+  viewer: Viewer = new LoggedOutViewer(this);
+
+  getViewer(): Viewer {
+    return this.viewer;
+  }
+}

package/src/testutils/db/fixture.ts

@@ -0,0 +1,32 @@
+import { Client } from "pg";
+import { Data } from "../../core/base";
+import { getFields, getStorageKey, Schema } from "../../schema";
+import { getDefaultValue } from "./value";
+import { buildInsertQuery } from "../../core/ent";
+
+interface Options {
+  overrides?: Data;
+  client: Client;
+  tableName: string;
+}
+
+export async function writeFixture(schema: Schema, opts: Options) {
+  const fields = getFields(schema);
+  const d: Data = {};
+  for (const [fieldName, field] of fields) {
+    const col = getStorageKey(field, fieldName);
+    const val = getDefaultValue(field, col);
+    d[col] = val;
+  }
+  if (opts.overrides) {
+    for (const k in opts.overrides) {
+      d[k] = opts.overrides[k];
+    }
+  }
+
+  const q = buildInsertQuery({
+    tableName: opts.tableName,
+    fields: d,
+  });
+  await opts.client.query(q[0], q[1]);
+}