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

package/src/action/privacy.ts

@@ -0,0 +1,37 @@
+import { Builder } from "./action";
+import {
+  Viewer,
+  ID,
+  Ent,
+  PrivacyResult,
+  PrivacyPolicyRule,
+  Deny,
+  Allow,
+  Skip,
+} from "../core/base";
+
+function isBuilder(node: ID | Builder<Ent, any>): node is Builder<Ent, any> {
+  return (node as Builder<Ent>).placeholderID !== undefined;
+}
+
+export class DenyIfBuilder implements PrivacyPolicyRule {
+  constructor(private id?: ID | Builder<Ent, any>) {}
+
+  async apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult> {
+    if (this.id && isBuilder(this.id)) {
+      return Deny();
+    }
+    return Skip();
+  }
+}
+
+export class AllowIfBuilder implements PrivacyPolicyRule {
+  constructor(private id?: ID | Builder<Ent, any>) {}
+
+  async apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult> {
+    if (this.id && isBuilder(this.id)) {
+      return Allow();
+    }
+    return Skip();
+  }
+}

package/src/action/relative_value.ts

@@ -0,0 +1,242 @@
+import {
+  Add,
+  Clause,
+  Divide,
+  Modulo,
+  Multiply,
+  Subtract,
+} from "../core/clause";
+
+export interface RelativeFieldValue<T = BigInt | number> {
+  delta: T;
+  sqlExpression: (col: string) => Clause;
+  eval: (curr: T) => T;
+}
+
+export interface RelativeNumberValue<T> {
+  add?: T;
+  subtract?: T;
+  divide?: T;
+  multiply?: T;
+  // note modulo only seems to work with integer types in postgres
+  modulo?: T;
+}
+
+// and then that translates to calling these which returns a RelativeFieldValue which is much cleaner?
+// can also do it one by one instead of what we had in
+
+// https://github.com/microsoft/TypeScript/issues/27808 is why we have the ts-expect-error below
+function addNumber(delta: number): RelativeFieldValue<number>;
+function addNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+function addNumber<T = number | BigInt>(delta: T): RelativeFieldValue<T> {
+  return {
+    delta,
+    sqlExpression(col: string): Clause {
+      return Add(col, delta);
+    },
+    eval(curr): T {
+      // @ts-expect-error
+      return curr + delta;
+    },
+  };
+}
+
+function subtractNumber(delta: number): RelativeFieldValue<number>;
+function subtractNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+function subtractNumber<T = number | BigInt>(delta: T): RelativeFieldValue<T> {
+  return {
+    delta,
+    sqlExpression(col: string): Clause {
+      return Subtract(col, delta);
+    },
+    eval(curr): T {
+      // @ts-expect-error
+      return curr - delta;
+    },
+  };
+}
+
+function multiplyNumber(delta: number): RelativeFieldValue<number>;
+function multiplyNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+function multiplyNumber<T = number | BigInt>(delta: T): RelativeFieldValue<T> {
+  return {
+    delta,
+    sqlExpression(col: string): Clause {
+      return Multiply(col, delta);
+    },
+    eval(curr): T {
+      // @ts-expect-error
+      return curr * delta;
+    },
+  };
+}
+
+function divideNumber(delta: number): RelativeFieldValue<number>;
+function divideNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+function divideNumber<T = BigInt | number>(delta: T): RelativeFieldValue<T> {
+  return {
+    delta,
+    sqlExpression(col: string): Clause {
+      return Divide(col, delta);
+    },
+    eval(curr): T {
+      // @ts-expect-error
+      return curr / delta;
+    },
+  };
+}
+
+// note modulo only seems to work with integer types in postgres
+function moduloNumber(delta: number): RelativeFieldValue<number>;
+function moduloNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+function moduloNumber<T = BigInt | number>(delta: T): RelativeFieldValue<T> {
+  return {
+    delta,
+    sqlExpression(col: string): Clause {
+      return Modulo(col, delta);
+    },
+    eval(curr): T {
+      // @ts-expect-error
+      return curr % delta;
+    },
+  };
+}
+
+export const NumberOps = {
+  addNumber,
+  moduloNumber,
+  divideNumber,
+  subtractNumber,
+  multiplyNumber,
+};
+
+export function convertRelativeInput(
+  rel: RelativeNumberValue<BigInt>,
+  col: string,
+  existing: BigInt,
+): { value: BigInt; clause: Clause };
+export function convertRelativeInput(
+  rel: RelativeNumberValue<number>,
+  col: string,
+  existing: number,
+): { value: number; clause: Clause };
+export function convertRelativeInput<T = BigInt | number>(
+  rel: RelativeNumberValue<T>,
+  col: string,
+  existing: T,
+): { value: T; clause: Clause } {
+  if (Object.keys(rel).length !== 1) {
+    throw new Error(`only 1 key is expected. ${Object.keys(rel).length} given`);
+  }
+  const ret = (relField: RelativeFieldValue<T>) => {
+    return {
+      value: relField.eval(existing),
+      clause: relField.sqlExpression(col),
+    };
+  };
+  if (rel.add !== undefined) {
+    // @ts-expect-error
+    return ret(addNumber(rel.add));
+  }
+  if (rel.subtract !== undefined) {
+    // @ts-expect-error
+    return ret(subtractNumber(rel.subtract));
+  }
+  if (rel.multiply !== undefined) {
+    // @ts-expect-error
+    return ret(multiplyNumber(rel.multiply));
+  }
+  if (rel.divide !== undefined) {
+    // @ts-expect-error
+    return ret(divideNumber(rel.divide));
+  }
+  if (rel.modulo !== undefined) {
+    // @ts-expect-error
+    return ret(moduloNumber(rel.modulo));
+  }
+  throw new Error(`error in convertRelativeInput. shouldn't have gotten here`);
+}
+
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: number | RelativeNumberValue<number>,
+  col: string,
+  existing: number,
+  expressions: Map<string, Clause>,
+): number;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: number | RelativeNumberValue<number> | undefined,
+  col: string,
+  existing: number,
+  expressions: Map<string, Clause>,
+): number | undefined;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: number | RelativeNumberValue<number> | null,
+  col: string,
+  existing: number | null,
+  expressions: Map<string, Clause>,
+): number | null;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: number | RelativeNumberValue<number> | null | undefined,
+  col: string,
+  existing: number | null,
+  expressions: Map<string, Clause>,
+): number | undefined | null;
+
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: BigInt | RelativeNumberValue<BigInt>,
+  col: string,
+  existing: BigInt,
+  expressions: Map<string, Clause>,
+): BigInt;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: BigInt | RelativeNumberValue<BigInt> | undefined,
+  col: string,
+  existing: BigInt,
+  expressions: Map<string, Clause>,
+): BigInt | undefined;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: BigInt | RelativeNumberValue<BigInt> | null,
+  col: string,
+  existing: BigInt | null,
+  expressions: Map<string, Clause>,
+): BigInt | null;
+export function maybeConvertRelativeInputPlusExpressions(
+  rel: BigInt | RelativeNumberValue<BigInt> | null | undefined,
+  col: string,
+  existing: BigInt | null,
+  expressions: Map<string, Clause>,
+): BigInt | null | undefined;
+
+export function maybeConvertRelativeInputPlusExpressions(
+  rel:
+    | number
+    | RelativeNumberValue<number>
+    | BigInt
+    | RelativeNumberValue<BigInt>
+    | null
+    | undefined,
+  col: string,
+  existing: number | BigInt | null,
+  expressions: Map<string, Clause>,
+): number | null | undefined | BigInt {
+  if (rel === null) {
+    return rel;
+  }
+  if (rel === undefined) {
+    return rel;
+  }
+
+  if (typeof rel === "bigint" || typeof rel === "number") {
+    return rel;
+  }
+
+  // // TODO is this the behavior we want? should we coalesce as 0?
+  // if (existing === null) {
+  //   throw new Error(`cannot perform a relative operation on null`);
+  // }
+  // @ts-ignore
+  // shouldn't be failing like it currently is. it thinks rel can be bigint  and it shouldn't be???
+  const { clause, value } = convertRelativeInput(rel, col, existing);
+  expressions.set(col, clause);
+  return value;
+}

package/src/action/transaction.ts

@@ -0,0 +1,38 @@
+import { Ent, Viewer } from "../core/base";
+import { Action, Builder, Changeset } from "./action";
+import { ComplexExecutor } from "./executor";
+
+type ActionAny = Action<
+  Ent<Viewer<any, any>>,
+  Builder<Ent<Viewer<any, any>>, Viewer<any, any>, any>,
+  Viewer<any, any>,
+  any,
+  any
+>;
+
+export class Transaction {
+  constructor(
+    private viewer: Viewer,
+    // independent operations
+    private actions: ActionAny[], // TODO ops for different types of transaction
+  ) {}
+
+  async run() {
+    const changesets: Changeset[] = [];
+    await Promise.all(
+      this.actions.map(async (action) => {
+        const c = await action.changeset();
+        changesets.push(c);
+      }),
+    );
+
+    const executor = new ComplexExecutor(
+      this.viewer,
+      "", // no placeholder, no opers
+      [],
+      new Map(),
+      changesets,
+    );
+    await executor.execute();
+  }
+}

package/src/auth/auth.ts

@@ -0,0 +1,77 @@
+import { Viewer } from "../core/base";
+import { LoggedOutViewer } from "../core/viewer";
+import { RequestContext, ContextCache } from "../core/context";
+import { IncomingMessage, ServerResponse } from "http";
+import { log } from "../core/logger";
+
+export type AuthViewer = Viewer | null;
+export interface AuthHandler {
+  authViewer(ctx: RequestContext): AuthViewer | Promise<AuthViewer>;
+}
+
+let handlers: Map<string, AuthHandler> = new Map();
+export async function registerAuthHandler(name: string, auth: AuthHandler) {
+  handlers.set(name, auth);
+}
+
+export async function clearAuthHandlers() {
+  handlers.clear();
+}
+
+export async function getLoggedInViewer(
+  context: RequestContext,
+): Promise<Viewer | null> {
+  for (const [name, authHandler] of handlers) {
+    let v = await authHandler.authViewer(context);
+    if (v !== null) {
+      log(
+        "info",
+        `auth handler \`${name}\` authenticated user \`${v.viewerID}\``,
+      );
+      return v;
+    }
+  }
+  log("info", "no auth handler returned viewer. default to logged out viewer");
+  return null;
+}
+
+export async function buildContext(
+  request: IncomingMessage,
+  response: ServerResponse,
+): Promise<RequestContext> {
+  const ctx = new contextImpl(request, response);
+  let viewer = await getLoggedInViewer(ctx);
+  if (viewer) {
+    // TODO since this is done, whatever other call to authViewer that was needed no longer needed
+    ctx.authViewer(viewer);
+  }
+  return ctx;
+}
+
+class contextImpl implements RequestContext {
+  cache?: ContextCache;
+  private loggedOutViewer: LoggedOutViewer;
+  private viewer: Viewer;
+
+  constructor(
+    public request: IncomingMessage,
+    public response: ServerResponse,
+  ) {
+    this.cache = new ContextCache();
+    // needs to be after this.cache above
+    this.loggedOutViewer = new LoggedOutViewer(this);
+    this.viewer = this.loggedOutViewer;
+  }
+
+  getViewer(): Viewer {
+    return this.viewer;
+  }
+
+  async authViewer(viewer: Viewer): Promise<void> {
+    this.viewer = viewer;
+  }
+
+  async logout(): Promise<void> {
+    this.viewer = this.loggedOutViewer;
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1,8 @@
+export {
+  AuthHandler,
+  AuthViewer,
+  registerAuthHandler,
+  clearAuthHandlers,
+  getLoggedInViewer,
+  buildContext,
+} from "./auth";