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

package/dist/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@snowtop/ent",
+  "version": "0.1.0-alpha160-test6",
+  "description": "snowtop ent framework",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "directories": {
+    "example": "examples"
+  },
+  "dependencies": {
+    "@types/node": "^20.2.5",
+    "camel-case": "^4.1.2",
+    "cosmiconfig": "^8.1.3",
+    "dataloader": "^2.2.2",
+    "glob": "^10.2.6",
+    "graph-data-structure": "^3.3.0",
+    "js-yaml": "^4.1.0",
+    "json5": "^2.2.3",
+    "luxon": "^3.3.0",
+    "memoizee": "^0.4.15",
+    "minimist": "^1.2.8",
+    "pascal-case": "^3.1.2",
+    "pg": "^8.11.0",
+    "prettier": "^2.8.8",
+    "snake-case": "^3.0.4",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "tslib": "^2.5.2",
+    "typescript": "^5.0.4",
+    "uuid": "^9.0.0"
+  },
+  "peerDependencies": {
+    "@swc-node/register": "^1.6.5",
+    "better-sqlite3": "^8.4.0",
+    "graphql": "^16.5.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "@swc-node/register": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=16.0"
+  },
+  "devDependencies": {},
+  "scripts": {},
+  "bin": {
+    "ent-custom-graphql": "scripts/custom_graphql.js",
+    "ent-custom-compiler": "scripts/custom_compiler.js"
+  },
+  "author": "lolopinto",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/lolopinto/ent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lolopinto/ent/issues"
+  },
+  "homepage": "https://github.com/lolopinto/ent#readme"
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha160-test5",
+  "version": "0.1.0-alpha160-test6",
   "description": "snowtop ent framework",
-  "main": "index.js",
+  "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "directories": {
     "example": "examples"
@@ -45,8 +45,50 @@
   "engines": {
     "node": ">=16.0"
   },
-  "devDependencies": {},
-  "scripts": {},
+  "devDependencies": {
+    "@swc/core": "^1.3.57",
+    "@swc/jest": "^0.2.26",
+    "@types/bcryptjs": "^2.4.2",
+    "@types/better-sqlite3": "^7.6.4",
+    "@types/express": "^4.17.15",
+    "@types/glob": "^8.0.0",
+    "@types/graphql-upload": "^8.0.12",
+    "@types/jest": "^29.2.4",
+    "@types/js-yaml": "^4.0.5",
+    "@types/luxon": "^3.1.0",
+    "@types/memoizee": "^0.4.8",
+    "@types/minimist": "^1.2.2",
+    "@types/passport": "^1.0.11",
+    "@types/passport-jwt": "^3.0.8",
+    "@types/pg": "^8.6.6",
+    "@types/pluralize": "0.0.29",
+    "@types/supertest": "^2.0.12",
+    "@types/uuid": "^9.0.0",
+    "better-sqlite3": "^8.4.0",
+    "email-addresses": "^5.0.0",
+    "express": "^4.18.2",
+    "graphql": "^16.6.0",
+    "graphql-helix": "^1.13.0",
+    "graphql-type-json": "^0.3.2",
+    "graphql-upload": "^13.0.0",
+    "jest": "^29.3.1",
+    "jest-date-mock": "^1.0.8",
+    "jest-each": "^29.5.0",
+    "jest-expect-message": "^1.1.3",
+    "jest-mock": "^29.3.1",
+    "node-sql-parser": "^3.9.4",
+    "object-path": "^0.11.8",
+    "pg-copy-streams": "^6.0.5",
+    "pluralize": "^8.0.0",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.1.0"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "test": "jest",
+    "clean": "rm -rf dist",
+    "prepublish": "npm run clean && npm run compile && node src/setupPackage.js"
+  },
   "bin": {
     "ent-custom-graphql": "scripts/custom_graphql.js",
     "ent-custom-compiler": "scripts/custom_compiler.js"
@@ -61,4 +103,4 @@
     "url": "https://github.com/lolopinto/ent/issues"
   },
   "homepage": "https://github.com/lolopinto/ent#readme"
-}
+}

package/src/action/action.ts

@@ -0,0 +1,330 @@
+import {
+  Ent,
+  EntConstructor,
+  Viewer,
+  ID,
+  Data,
+  PrivacyPolicy,
+  Context,
+  WriteOperation,
+} from "../core/base";
+import { loadEdgeForID2, AssocEdge } from "../core/ent";
+import { DataOperation, AssocEdgeInputOptions } from "./operations";
+import { Queryer } from "../core/db";
+import { log } from "../core/logger";
+import { TransformedUpdateOperation, UpdateOperation } from "../schema";
+import { FieldInfoMap } from "../schema/schema";
+
+export { WriteOperation };
+
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+
+interface BuilderOrchestrator {
+  __getOptions(): {
+    fieldInfo: FieldInfoMap;
+  };
+}
+
+export interface Builder<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
+> {
+  existingEnt: TExistingEnt;
+  ent: EntConstructor<TEnt, TViewer>;
+  placeholderID: ID;
+  readonly viewer: TViewer;
+  build(): Promise<Changeset>;
+  buildWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
+  operation: WriteOperation;
+  editedEnt?(): Promise<TEnt | null>;
+  nodeType: string;
+  // TODO TInput in Builder
+  getInput(): Data;
+  // TODO full orchestrator...
+  orchestrator: BuilderOrchestrator;
+}
+
+// PS: this is a private API subject to change
+export interface Executor
+  extends Iterable<DataOperation>,
+    Iterator<DataOperation> {
+  placeholderID: ID;
+  // this returns a non-privacy checked "ent"
+  resolveValue(val: any): Ent | null;
+  builderOpChanged(builder: Builder<any>): boolean;
+  builder?: Builder<Ent>;
+
+  execute(): Promise<void>;
+
+  // TODO add this so we can differentiate btw when ops are being executed?
+  // vs gathered for other use
+  // or change how execute() works?
+  // right now have to reset at the end of next() if we call for (const op of executor) {}
+  // also want to throw if DataOperation.returnedRow or DataOperation.createdEnt
+  // called too early
+  //  getSortedOps(): DataOperation[];
+
+  // these 3 are to help chained/contained executors
+  preFetch?(queryer: Queryer, context?: Context): Promise<void>;
+  postFetch?(queryer: Queryer, context?: Context): Promise<void>;
+  executeObservers?(): Promise<void>;
+}
+
+export interface Changeset {
+  executor(): Executor;
+  viewer: Viewer;
+  placeholderID: ID;
+  //  ent: EntConstructor<T>;
+  changesets?: Changeset[];
+  dependencies?: Map<ID, Builder<Ent>>;
+}
+
+export type TriggerReturn =
+  | void
+  | Promise<Changeset | void | (Changeset | void)[]>
+  | Promise<Changeset>[];
+
+export interface Trigger<
+  TEnt extends Ent<TViewer>,
+  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
+  TViewer extends Viewer = Viewer,
+  TInput extends Data = Data,
+  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
+> {
+  // TODO: way in the future. detect any writes happening in changesets and optionally throw if configured to do so
+  // can throw if it wants. not expected to throw tho.
+  // input passed in here !== builder.getInput()
+  // builder.getInput() can have other default fields
+  changeset(builder: TBuilder, input: TInput): TriggerReturn;
+}
+
+export interface Observer<
+  TEnt extends Ent<TViewer>,
+  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
+  TViewer extends Viewer = Viewer,
+  TInput extends Data = Data,
+  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
+> {
+  // input passed in here !== builder.getInput()
+  // builder.getInput() can have other default fields
+  observe(builder: TBuilder, input: TInput): void | Promise<void>;
+}
+
+export interface Validator<
+  TEnt extends Ent<TViewer>,
+  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
+  TViewer extends Viewer = Viewer,
+  TInput extends Data = Data,
+  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
+> {
+  // can throw if it wants
+  // input passed in here !== builder.getInput()
+  // builder.getInput() can have other default fields
+  validate(
+    builder: TBuilder,
+    input: TInput,
+  ): Promise<void | undefined | Error> | void | Error | undefined;
+}
+
+export interface ChangesetOptions {
+  // conditional on builder operation remaining the same
+  // TODO I don't really like this
+  // https://github.com/lolopinto/ent/issues/1437
+  conditionalBuilder: Builder<any, any>;
+}
+
+export interface Action<
+  TEnt extends Ent<TViewer>,
+  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
+  TViewer extends Viewer = Viewer,
+  TInput extends Data = Data,
+  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
+> {
+  readonly viewer: Viewer;
+  changeset(): Promise<Changeset>;
+  changesetWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
+  builder: TBuilder;
+  getPrivacyPolicy(): PrivacyPolicy<TEnt>;
+
+  // we allow grouping triggers to indicate dependency trees
+  // so that you can say one or more triggers is higher priority
+  // than the others and should be run first
+  // any encountered list is a different priority from prior and subsequent triggers
+  getTriggers?(): (
+    | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>
+    | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[]
+  )[];
+  getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+  getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+  getInput(): TInput; // this input is passed to Triggers, Observers, Validators
+  transformWrite?: (
+    stmt: UpdateOperation<TEnt, TViewer>,
+  ) =>
+    | Promise<TransformedUpdateOperation<TEnt, TViewer>>
+    | TransformedUpdateOperation<TEnt, TViewer>
+    | null;
+
+  valid(): Promise<boolean>;
+  // throws if invalid
+  validX(): Promise<void>;
+
+  // this is used to load the ent after the action
+  // you can imagine this being overwritten for a create user or create account
+  // action to load the just-created user after the fact
+  viewerForEntLoad?(
+    data: Data,
+    context?: Context<TViewer>,
+  ): TViewer | Promise<TViewer>;
+
+  // if we have overloads we need to provide all which sucks
+  // so maybe don't make the ones below required
+  // save(): Promise<T | null>;
+  // save(): Promise<void>;
+  // saveX(): Promise<T>;
+  // saveX(): Promise<T>;
+}
+
+export async function saveBuilder<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(builder: Builder<TEnt, TViewer>): Promise<void> {
+  await saveBuilderImpl(builder, false);
+}
+
+export async function saveBuilderX<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(builder: Builder<TEnt, TViewer>): Promise<void> {
+  await saveBuilderImpl(builder, true);
+}
+
+async function saveBuilderImpl<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(builder: Builder<TEnt, TViewer>, throwErr: boolean): Promise<void> {
+  let changeset: Changeset;
+  try {
+    changeset = await builder.build();
+  } catch (e) {
+    log("error", e);
+    if (throwErr) {
+      throw e;
+    } else {
+      // expected...
+      return;
+    }
+  }
+  const executor = changeset.executor();
+  if (throwErr) {
+    return executor.execute();
+  } else {
+    try {
+      return executor.execute();
+    } catch (e) {
+      // it's already caught and logged upstream
+    }
+  }
+}
+
+// Orchestrator in orchestrator.ts in generated Builders
+// we indicate the API we expect here. Not typing it to Orchestrator class in Orchestrator.ts
+// for flexibility
+interface Orchestrator {
+  addOutboundEdge<T2 extends Ent>(
+    id2: ID | Builder<T2>,
+    edgeType: string,
+    nodeType: string,
+    options?: AssocEdgeInputOptions,
+  ): void;
+  removeOutboundEdge(id2: ID, edgeType: string): void;
+  viewer: Viewer;
+}
+
+async function modifyEdgeSet<T extends string>(
+  orchestrator: Orchestrator,
+  id1: ID,
+  id2: ID,
+  inputEnumValue: string,
+  enumValue: string,
+  edgeType: T,
+  nodeType: string,
+) {
+  let edge = await loadEdgeForID2({
+    id1: id1,
+    id2: id2,
+    edgeType: edgeType,
+    ctr: AssocEdge,
+    context: orchestrator.viewer.context,
+  });
+  // always add the edge because the data field may be getting overwritten later on
+  // and we need to give that operation a chance to succeed
+  // TODO: can save a write here by checking in EdgeOperation and not doing this write if nothing
+  // has changed.
+  if (inputEnumValue === enumValue) {
+    orchestrator.addOutboundEdge(id2, edgeType, nodeType);
+  }
+  if (edge) {
+    if (enumValue !== inputEnumValue) {
+      orchestrator.removeOutboundEdge(id2, edgeType);
+    }
+  }
+}
+
+// This sets one edge in a group
+// used for assoc groups where setting the value of one edge in the group
+// unsets the other
+// e.g. 3 states for event rsvp: attending, maybe, declined. user can't be rsvped as more than one at a time so this helps you
+// so that setting an rsvp status for one clears the others (if set)
+// or for friendship status: incoming_friend_request, outgoing_friend_request, are_friends
+// accepting a friend request should clear an incoming or outgoing friend request
+// @args
+// orchestrator: see interface
+// inputEnumValue: the value of the enum. should be one of the keys of m
+// id1: source ID in Orchestrator. We take this as extra param because we need it to check if edge exists
+// id2: target id
+// nodeType: nodeType of ent in question
+// m: Map<enumType, to EdgeType to check>
+export async function setEdgeTypeInGroup<T extends string>(
+  orchestrator: Orchestrator,
+  inputEnumValue: string,
+  id1: ID,
+  id2: ID,
+  nodeType: string,
+  m: Map<T, string>,
+) {
+  let promises: Promise<void>[] = [];
+  for (const [k, v] of m) {
+    promises.push(
+      modifyEdgeSet(orchestrator, id1, id2, inputEnumValue, k, v, nodeType),
+    );
+  }
+  await Promise.all(promises);
+}
+
+export async function clearEdgeTypeInGroup<T extends string>(
+  orchestrator: Orchestrator,
+  id1: ID,
+  id2: ID,
+  m: Map<T, string>,
+) {
+  let promises: Promise<void>[] = [];
+  for (const [_, edgeType] of m) {
+    promises.push(
+      (async () => {
+        let edge = await loadEdgeForID2({
+          id1,
+          id2,
+          edgeType,
+          ctr: AssocEdge,
+          context: orchestrator.viewer.context,
+        });
+        if (edge) {
+          orchestrator.removeOutboundEdge(id2, edgeType);
+        }
+      })(),
+    );
+  }
+  await Promise.all(promises);
+}