joist-orm 0.1.536 → 1.0.0

package/src/EntityPersister.ts

@@ -1,240 +0,0 @@
-import Knex from "knex";
-import { JoinRow, ManyToManyCollection } from "./collections/ManyToManyCollection";
-import {
-  deTagIds,
-  Entity,
-  EntityMetadata,
-  getMetadata,
-  keyToNumber,
-  keyToString,
-  maybeResolveReferenceToId,
-} from "./index";
-import { partition } from "./utils";
-
-/** The operations for a given entity type, so they can be executed in bulk. */
-export interface Todo {
-  metadata: EntityMetadata<any>;
-  inserts: Entity[];
-  updates: Entity[];
-  deletes: Entity[];
-  validates: Entity[];
-}
-
-export async function flushEntities(knex: Knex, todos: Record<string, Todo>): Promise<void> {
-  const updatedAt = new Date();
-  await assignNewIds(knex, todos);
-  for await (const todo of Object.values(todos)) {
-    if (todo) {
-      const meta = todo.metadata;
-      if (todo.inserts.length > 0) {
-        await batchInsert(knex, meta, todo.inserts);
-      }
-      if (todo.updates.length > 0) {
-        todo.updates.forEach((e) => (e.__orm.data["updatedAt"] = updatedAt));
-        await batchUpdate(knex, meta, todo.updates);
-      }
-      if (todo.deletes.length > 0) {
-        await batchDelete(knex, meta, todo.deletes);
-      }
-    }
-  }
-}
-
-/**
- * Assigns all new entities an id directly from their corresponding sequence generator, instead of via INSERTs.
- *
- * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves
- * need to first be INSERTed.
- */
-async function assignNewIds(knex: Knex, todos: Record<string, Todo>): Promise<void> {
-  const seqStatements: string[] = [];
-  Object.values(todos).forEach((todo) => {
-    if (todo.inserts.length > 0) {
-      const meta = todo.inserts[0].__orm.metadata;
-      const sequenceName = `${meta.tableName}_id_seq`;
-      const sql = `select nextval('${sequenceName}') from generate_series(1, ${todo.inserts.length})`;
-      seqStatements.push(sql);
-    }
-  });
-  if (seqStatements.length > 0) {
-    // There will be 1 per table; 1 single insert should be fine but we might need to batch for super-large schemas?
-    const sql = seqStatements.join(" UNION ALL ");
-    const result = await knex.raw(sql);
-    let i = 0;
-    Object.values(todos).forEach((todo) => {
-      for (const insert of todo.inserts) {
-        insert.__orm.data["id"] = keyToString(todo.metadata, result.rows![i++]["nextval"]);
-      }
-    });
-  }
-}
-
-async function batchInsert(knex: Knex, meta: EntityMetadata<any>, entities: Entity[]): Promise<void> {
-  const rows = entities.map((entity) => {
-    const row = {};
-    meta.columns.forEach((c) => c.serde.setOnRow(entity.__orm.data, row));
-    return row;
-  });
-  // We don't use the ids that come back from batchInsert b/c we pre-assign ids for both inserts and updates.
-  // We also use `.transacting` b/c even when `knex` is already a Transaction object,
-  // `batchInsert` w/o the `transacting` adds savepoints that we don't want/need.
-  await knex.batchInsert(meta.tableName, rows).transacting(knex as any);
-  for (let i = 0; i < entities.length; i++) {
-    entities[i].__orm.originalData = {};
-  }
-}
-
-// Uses a pg-specific syntax to issue a bulk update
-async function batchUpdate(knex: Knex, meta: EntityMetadata<any>, entities: Entity[]): Promise<void> {
-  // Get the unique set of fields that are changed across all of the entities (of this type) we want to bulk update
-  const changedFields = new Set<string>();
-  // Id doesn't change, but we need it for our WHERE clause
-  changedFields.add("id");
-  entities.forEach((entity) => {
-    Object.keys(entity.__orm.originalData).forEach((key) => changedFields.add(key));
-  });
-
-  // Sometimes with derived fields, an instance will be marked as an update, but if the derived field hasn't changed,
-  // it'll be a noop, so just short-circuit if it looks like that happened, i.e. we have no changed fields.
-  if (changedFields.size === 1) {
-    return;
-  }
-
-  // This currently assumes a 1-to-1 field-to-column mapping.
-  const columns = meta.columns.filter((c) => changedFields.has(c.fieldName));
-  const bindings: any[][] = columns.map(() => []);
-  for (const entity of entities) {
-    columns.forEach((c, i) => {
-      bindings[i].push(c.serde.getFromEntity(entity.__orm.data) ?? null);
-    });
-  }
-  await knex.raw(
-    cleanSql(`
-      UPDATE ${meta.tableName}
-      SET ${columns
-        .filter((c) => c.columnName !== "id")
-        .map((c) => `"${c.columnName}" = data."${c.columnName}"`)
-        .join(", ")}
-      FROM (select ${columns.map((c) => `unnest(?::${c.dbType}[]) as "${c.columnName}"`).join(", ")}) as data
-      WHERE ${meta.tableName}.id = data.id
-   `),
-    bindings,
-  );
-  entities.forEach((entity) => (entity.__orm.originalData = {}));
-}
-
-async function batchDelete(knex: Knex, meta: EntityMetadata<any>, entities: Entity[]): Promise<void> {
-  await knex(meta.tableName)
-    .del()
-    .whereIn(
-      "id",
-      entities.map((e) => keyToNumber(meta, e.id!).toString()),
-    );
-  entities.forEach((entity) => (entity.__orm.deleted = "deleted"));
-}
-
-function cleanSql(sql: string): string {
-  return sql.trim().replace(/\n/g, "").replace(/  +/g, " ");
-}
-
-/**
- * Scans `entities` for new/updated entities and arranges them per-type in entity order.
- *
- * This currently assumes the entity types in the schema can be topographically sorted
- * and have no cycles, i.e. `books` always depend on `authors` (due to the `books.author_id`
- * foreign key), but `authors` never (via a required foreign key) depend on `books`.
- */
-export function sortEntities(entities: Entity[]): Record<string, Todo> {
-  const todos: Record<string, Todo> = {};
-  for (const entity of entities) {
-    if (entity.isPendingFlush) {
-      const todo = getTodo(todos, entity);
-      if (entity.isPendingDelete) {
-        todo.deletes.push(entity);
-      } else if (entity.isNewEntity) {
-        todo.inserts.push(entity);
-      } else {
-        todo.updates.push(entity);
-      }
-    }
-  }
-  return todos;
-}
-
-/** getOrSets a `Todo` for `entity` in `todos`. */
-export function getTodo(todos: Record<string, Todo>, entity: Entity): Todo {
-  const meta = getMetadata(entity);
-  let todo = todos[meta.type];
-  if (!todo) {
-    todo = { metadata: entity.__orm.metadata, inserts: [], updates: [], deletes: [], validates: [] };
-    todos[meta.type] = todo;
-  }
-  return todo;
-}
-
-export async function flushJoinTables(knex: Knex, joinRows: Record<string, JoinRowTodo>): Promise<void> {
-  for await (const [joinTableName, { m2m, newRows, deletedRows }] of Object.entries(joinRows)) {
-    if (newRows.length > 0) {
-      const ids = await knex
-        .batchInsert(
-          joinTableName,
-          newRows.map((row) => {
-            // The rows in EntityManager.joinRows point to entities, change those to ints
-            const { id, created_at, m2m, ...fkColumns } = row;
-            Object.keys(fkColumns).forEach((key) => {
-              const meta = key == m2m.columnName ? getMetadata(m2m.entity) : m2m.otherMeta;
-              fkColumns[key] = keyToNumber(meta, maybeResolveReferenceToId(fkColumns[key]));
-            });
-            return fkColumns;
-          }),
-        )
-        .returning("id");
-      for (let i = 0; i < ids.length; i++) {
-        newRows[i].id = ids[i];
-      }
-    }
-    if (deletedRows.length > 0) {
-      // `remove`s that were done against unloaded ManyToManyCollections will not have row ids
-      const [haveIds, noIds] = partition(deletedRows, (r) => r.id !== -1);
-
-      if (haveIds.length > 0) {
-        await knex(joinTableName)
-          .del()
-          .whereIn(
-            "id",
-            haveIds.map((e) => e.id!),
-          );
-      }
-
-      if (noIds.length > 0) {
-        const data = noIds.map(
-          (e) =>
-            [
-              deTagIds(m2m.meta, [maybeResolveReferenceToId(e[m2m.columnName])!])[0],
-              deTagIds(m2m.otherMeta, [maybeResolveReferenceToId(e[m2m.otherColumnName])!])[0],
-            ] as any,
-        );
-        await knex(joinTableName).del().whereIn([m2m.columnName, m2m.otherColumnName], data);
-      }
-    }
-  }
-}
-
-interface JoinRowTodo {
-  // Store the m2m reference (either side of the m2m, it doesn't matter which) to help tag/untag the foreign keys
-  m2m: ManyToManyCollection<any, any>;
-  newRows: JoinRow[];
-  deletedRows: JoinRow[];
-}
-
-export function sortJoinRows(joinRows: Record<string, JoinRow[]>): Record<string, JoinRowTodo> {
-  const todos: Record<string, JoinRowTodo> = {};
-  for (const [joinTableName, rows] of Object.entries(joinRows)) {
-    const newRows = rows.filter((r) => r.id === undefined && r.deleted !== true);
-    const deletedRows = rows.filter((r) => r.id !== undefined && r.deleted === true);
-    if (newRows.length > 0 || deletedRows.length > 0) {
-      todos[joinTableName] = { newRows, deletedRows, m2m: rows[0].m2m };
-    }
-  }
-  return todos;
-}

package/src/QueryBuilder.ts

@@ -1,289 +0,0 @@
-import Knex, { QueryBuilder } from "knex";
-import {
-  ColumnMeta,
-  Entity,
-  EntityConstructor,
-  entityLimit,
-  EntityMetadata,
-  FilterOf,
-  getMetadata,
-  isEntity,
-  OrderOf,
-} from "./EntityManager";
-import { ForeignKeySerde } from "./serde";
-import { fail } from "./utils";
-
-export type OrderBy = "ASC" | "DESC";
-
-export type BooleanFilter<N> = true | false | N;
-
-export type ValueFilter<V, N> =
-  | V
-  | V[]
-  | N
-  // Both eq and in are redundant with `V` and `V[]` above but are convenient for matching GQL filter APIs
-  | { eq: V | N }
-  | { in: V[] }
-  | { gt: V }
-  | { gte: V }
-  | { ne: V | N }
-  | { lt: V }
-  | { lte: V }
-  | { like: V }
-  | { ilike: V };
-
-// For filtering by a foreign key T, i.e. either joining/recursing into with FilterQuery<T>, or matching it is null/not null/etc.
-export type EntityFilter<T, I, F, N> = T | I | I[] | F | N | { ne: T | I | N };
-
-export type BooleanGraphQLFilter = true | false | null;
-
-export type Primitive = string | boolean | Date | number;
-
-/** This essentially matches the ValueFilter but with looser types to placate GraphQL. */
-export type ValueGraphQLFilter<V> =
-  | {
-      eq?: V | null;
-      in?: V[] | null;
-      gt?: V | null;
-      gte?: V | null;
-      ne?: V | null;
-      lt?: V | null;
-      lte?: V | null;
-      like?: V | null;
-      ilike?: V | null;
-    }
-  | { op: Operator; value: Primitive }
-  | V
-  | V[]
-  | null;
-
-export type EnumGraphQLFilter<V> = V[] | null | undefined;
-
-/** A GraphQL version of EntityFilter. */
-export type EntityGraphQLFilter<T, I, F> = T | I | I[] | F | { ne: T | I } | null | undefined;
-
-const operators = ["eq", "gt", "gte", "ne", "lt", "lte", "like", "ilike", "in"] as const;
-export type Operator = typeof operators[number];
-const opToFn: Record<Operator, string> = {
-  eq: "=",
-  gt: ">",
-  gte: ">=",
-  ne: "!=",
-  lt: "<",
-  lte: "<=",
-  like: "LIKE",
-  ilike: "ILIKE",
-  in: "...",
-};
-
-export type FilterAndSettings<T> = {
-  where: FilterOf<T>;
-  orderBy?: OrderOf<T>;
-  limit?: number;
-  offset?: number;
-};
-
-/**
- * Builds the SQL/knex queries for `EntityManager.find` calls.
- *
- * Note this is generally for our own internal implementation details and not meant to
- * be a user-facing QueryBuilder, i.e. users should use Knex for that and just use SQL
- * directly (for any non-trivial queries that `EntityManager.find` does not support).
- */
-export function buildQuery<T extends Entity>(
-  knex: Knex,
-  type: EntityConstructor<T>,
-  filter: FilterAndSettings<T>,
-): QueryBuilder<{}, unknown[]> {
-  const meta = getMetadata(type);
-  const { where, orderBy, limit, offset } = filter;
-
-  const aliases: Record<string, number> = {};
-  function getAlias(tableName: string): string {
-    const abbrev = abbreviation(tableName);
-    const i = aliases[abbrev] || 0;
-    aliases[abbrev] = i + 1;
-    return `${abbrev}${i}`;
-  }
-
-  const alias = getAlias(meta.tableName);
-  let query: QueryBuilder<any, any> = knex.select<unknown>(`${alias}.*`).from(`${meta.tableName} AS ${alias}`);
-
-  // Define a function for recursively adding joins & filters
-  function addClauses(
-    meta: EntityMetadata<any>,
-    alias: string,
-    where: object | undefined,
-    orderBy: object | undefined,
-  ): void {
-    // Combine the where and orderBy keys so that we can add them to aliases as that same time
-    const keys = [...(where ? Object.keys(where) : []), ...(orderBy ? Object.keys(orderBy) : [])];
-
-    keys.forEach((key) => {
-      const column = meta.columns.find((c) => c.fieldName === key) || fail(`${key} not found`);
-
-      // We may/may not have a where clause or orderBy for this key, but we should have at least one of them.
-      const clause = where && (where as any)[key];
-      const hasClause = where && key in where;
-      const order = orderBy && (orderBy as any)[key];
-      const hasOrder = !!order;
-
-      if (column.serde instanceof ForeignKeySerde) {
-        // Add `otherTable.column = ...` clause, unless `key` is not in `where`, i.e. there is only an orderBy for this fk
-        let [whereNeedsJoin, _query] = hasClause ? addForeignKeyClause(query, alias, column, clause) : [false, query];
-        query = _query;
-        if (whereNeedsJoin || hasOrder) {
-          // Add a join for this column
-          const otherMeta = column.serde.otherMeta();
-          const otherAlias = getAlias(otherMeta.tableName);
-          query = query.innerJoin(
-            `${otherMeta.tableName} AS ${otherAlias}`,
-            `${alias}.${column.columnName}`,
-            `${otherAlias}.id`,
-          );
-          // Then recurse to add its conditions to the query
-          addClauses(otherMeta, otherAlias, whereNeedsJoin ? clause : undefined, hasOrder ? order : undefined);
-        }
-      } else {
-        query = hasClause ? addPrimitiveClause(query, alias, column, clause) : query;
-        // This is not a foreign key column, so it'll have the primitive filters/order bys
-        if (order) {
-          query = query.orderBy(`${alias}.${column.columnName}`, order);
-        }
-      }
-    });
-  }
-
-  addClauses(meta, alias, where as object, orderBy as object);
-
-  // Even if they already added orders, add id as the last one to get deterministic output
-  query = query.orderBy(`${alias}.id`);
-  query = query.limit(limit || entityLimit);
-  if (offset) {
-    query = query.offset(offset);
-  }
-
-  return query as QueryBuilder<{}, unknown[]>;
-}
-
-function abbreviation(tableName: string): string {
-  return tableName
-    .split("_")
-    .map((w) => w[0])
-    .join("");
-}
-
-function addForeignKeyClause(
-  query: QueryBuilder,
-  alias: string,
-  column: ColumnMeta,
-  clause: any,
-): [boolean, QueryBuilder] {
-  // I.e. this could be { authorFk: authorEntity | null | id | { ...recurse... } }
-  const clauseKeys = typeof clause === "object" && clause !== null ? Object.keys(clause as object) : [];
-  if (isEntity(clause) || typeof clause == "string" || Array.isArray(clause)) {
-    // I.e. { authorFk: authorEntity | id | id[] }
-    if (isEntity(clause) && clause.id === undefined) {
-      // The user is filtering on an unsaved entity, which will just never have any rows, so throw in -1
-      return [false, query.where(`${alias}.${column.columnName}`, -1)];
-    } else if (Array.isArray(clause)) {
-      return [
-        false,
-        query.whereIn(
-          `${alias}.${column.columnName}`,
-          clause.map((id) => column.serde.mapToDb(id)),
-        ),
-      ];
-    } else {
-      return [false, query.where(`${alias}.${column.columnName}`, column.serde.mapToDb(clause))];
-    }
-  } else if (clause === null || clause === undefined) {
-    // I.e. { authorFk: null | undefined }
-    return [false, query.whereNull(`${alias}.${column.columnName}`)];
-  } else if (clauseKeys.length === 1 && clauseKeys[0] === "id") {
-    // I.e. { authorFk: { id: string } } || { authorFk: { id: string[] } }
-    // If only querying on the id, we can skip the join
-    const value = (clause as any)["id"];
-    if (Array.isArray(value)) {
-      return [
-        false,
-        query.whereIn(
-          `${alias}.${column.columnName}`,
-          value.map((id) => column.serde.mapToDb(id)),
-        ),
-      ];
-    } else {
-      return [false, query.where(`${alias}.${column.columnName}`, column.serde.mapToDb(value))];
-    }
-  } else if (clauseKeys.length === 1 && clauseKeys[0] === "ne") {
-    // I.e. { authorFk: { ne: string | null | undefined } }
-    const value = (clause as any)["ne"];
-    if (value === null || value === undefined) {
-      return [false, query.whereNotNull(`${alias}.${column.columnName}`)];
-    } else if (typeof value === "string") {
-      return [false, query.whereNot(`${alias}.${column.columnName}`, column.serde.mapToDb(value))];
-    } else {
-      throw new Error("Not implemented");
-    }
-  } else {
-    // I.e. { authorFk: { ...authorFilter... } }
-    return [clause !== undefined, query];
-  }
-}
-
-function addPrimitiveClause(query: QueryBuilder, alias: string, column: ColumnMeta, clause: any): QueryBuilder {
-  if (clause && typeof clause === "object" && operators.find((op) => Object.keys(clause).includes(op))) {
-    // I.e. `{ primitiveField: { gt: value } }`
-    const op = Object.keys(clause)[0] as Operator;
-    return addPrimitiveOperator(query, alias, column, op, (clause as any)[op]);
-  } else if (clause && typeof clause === "object" && "op" in clause) {
-    // I.e. { primitiveField: { op: "gt", value: 1 } }`
-    return addPrimitiveOperator(query, alias, column, clause.op, clause.value);
-  } else if (Array.isArray(clause)) {
-    // I.e. `{ primitiveField: value[] }`
-    return query.whereIn(
-      `${alias}.${column.columnName}`,
-      clause.map((v) => column.serde.mapToDb(v)),
-    );
-  } else if (clause === null) {
-    // I.e. `{ primitiveField: null }`
-    return query.whereNull(`${alias}.${column.columnName}`);
-  } else if (clause === undefined) {
-    // I.e. `{ primitiveField: undefined }`
-    // Currently we treat this like a partial filter, i.e. don't include it. Seems odd
-    // unless this is opt-in, i.e. maybe only do this for `findGql`?
-    return query;
-  } else if (clause !== undefined) {
-    // I.e. `{ primitiveField: value }`
-    // TODO In theory could add a addToQuery method to Serde to generalize this to multi-columns fields.
-    return query.where(`${alias}.${column.columnName}`, column.serde.mapToDb(clause));
-  } else {
-    return fail(`Unhandled primitive clause ${clause}`);
-  }
-}
-
-function addPrimitiveOperator(
-  query: QueryBuilder,
-  alias: string,
-  column: ColumnMeta,
-  op: Operator,
-  value: any,
-): QueryBuilder {
-  if (value === null || value === undefined) {
-    if (op === "ne") {
-      return query.whereNotNull(`${alias}.${column.columnName}`);
-    } else if (op === "eq") {
-      return query.whereNull(`${alias}.${column.columnName}`);
-    } else {
-      throw new Error("Only ne is supported when the value is undefined or null");
-    }
-  } else if (op === "in") {
-    return query.whereIn(
-      `${alias}.${column.columnName}`,
-      (value as Array<any>).map((v) => column.serde.mapToDb(v)),
-    );
-  } else {
-    const fn = opToFn[op] || fail(`Invalid operator ${op}`);
-    return query.where(`${alias}.${column.columnName}`, fn, column.serde.mapToDb(value));
-  }
-}

package/src/changes.ts

@@ -1,40 +0,0 @@
-import { Entity, IdOf, OptsOf } from "./EntityManager";
-
-/** Exposes a field's changed/original value in each entity's `this.changes` property. */
-export interface FieldStatus<T> {
-  hasChanged: boolean;
-  originalValue?: T;
-}
-
-type NullOrDefinedOr<T> = T | null | undefined;
-type ExcludeNever<T> = Pick<T, { [P in keyof T]: T[P] extends never ? never : P }[keyof T]>;
-
-/**
- * Creates the `this.changes.firstName` changes API for a given entity `T`.
- *
- * Specifically we use the fields from OptsOf but:
- *
- * - Exclude collections
- * - Convert entity types to id types to match what is stored in originalData
- */
-export type Changes<T extends Entity> = ExcludeNever<
-  {
-    [P in keyof OptsOf<T>]-?: OptsOf<T>[P] extends NullOrDefinedOr<infer U>
-      ? U extends Array<any>
-        ? never
-        : U extends Entity
-        ? FieldStatus<IdOf<U>>
-        : FieldStatus<U>
-      : never;
-  }
->;
-
-export function newChangesProxy<T extends Entity>(entity: T): Changes<T> {
-  return new Proxy(entity, {
-    get(target, p: PropertyKey): FieldStatus<any> {
-      const originalValue = typeof p === "string" && entity.__orm.originalData[p];
-      const hasChanged = typeof p === "string" && p in entity.__orm.originalData && entity.id !== undefined;
-      return { hasChanged, originalValue };
-    },
-  }) as any;
-}

package/src/collections/AbstractRelationImpl.ts

@@ -1,28 +0,0 @@
-/**
- * Defines common hooks that relations can respond to to keep the entity graph in sync.
- */
-export abstract class AbstractRelationImpl<U> {
-  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */
-  abstract setFromOpts(value: U): void;
-
-  /** Called on each relation of a new entity, since we know it defacto can be marked as loaded. */
-  abstract initializeForNewEntity(): void;
-
-  /** Similar to setFromOpts, but called post-construction. */
-  abstract set(value: U): void;
-
-  /** Called on `EntityManager.refresh()` to reload the collection from the latest db values. */
-  abstract async refreshIfLoaded(): Promise<void>;
-
-  /**
-   * Called when our entity has been `EntityManager.delete`'d _and_ `EntityManager.flush` is being called,
-   * so we can unset any foreign keys to the being-deleted entity.
-   */
-  abstract async onEntityDeletedAndFlushing(): Promise<void>;
-
-  /**
-   * Called when our entity has been `EntityManager.delete`'d so that we can run any special behavior
-   * like cascades
-   */
-  abstract onEntityDelete(): void;
-}