@fitzzero/quickdraw-core 5.1.1 → 5.1.3

package/dist/prisma/index.js

@@ -1,75 +1,84 @@
+import {
+  findNestedWrites
+} from "../chunk-XH2IZVLT.js";
 import {
   createWriteTracker,
   quietly
-} from "../chunk-4DIQHASK.js";
-import "../chunk-DD4SKCNO.js";
+} from "../chunk-SQ5VUG77.js";
+import "../chunk-RZXJTDH5.js";
 import {
   STORAGE_KEY,
   createInterestRegistry,
+  createLinkRegistry,
   modelKey,
   storageOf
-} from "../chunk-H23KEFBA.js";
+} from "../chunk-DUBU3BB3.js";
 import {
   consoleLogger
-} from "../chunk-YSWH776Y.js";
-import "../chunk-4YO5H5ON.js";
+} from "../chunk-DKE6QO26.js";
+import "../chunk-Q4OGQM5I.js";
+import "../chunk-QSU47XEX.js";
 
-// src/prisma/nested.ts
-var NESTED_KEYS = [
-  "create",
-  "createMany",
-  "connect",
-  "connectOrCreate",
-  "disconnect",
-  "set",
-  "update",
-  "updateMany",
-  "upsert",
-  "delete",
-  "deleteMany"
-];
-var FLAG_KEYS = /* @__PURE__ */ new Set(["delete", "disconnect"]);
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isRows(value) {
-  return Array.isArray(value) || isPlainObject(value);
-}
-function isRelationSet(value) {
-  return Array.isArray(value) ? value.some(isPlainObject) : isPlainObject(value);
-}
-function writesRelation(value, key) {
-  if (!Object.hasOwn(value, key)) {
-    return false;
-  }
-  const operand = value[key];
-  if (key === "set") {
-    return isRelationSet(operand);
+// src/prisma/links.ts
+var UNREAD = /* @__PURE__ */ new WeakMap();
+function warnUnread(runtime, model, junction) {
+  const warned = UNREAD.get(runtime) ?? /* @__PURE__ */ new Set();
+  UNREAD.set(runtime, warned);
+  const key = `${model}\0${junction}`;
+  if (warned.has(key)) {
+    return;
   }
-  return isRows(operand) || FLAG_KEYS.has(key) && operand === true;
+  warned.add(key);
+  runtime.tracker.logger.warn(
+    `Reading the ${junction} rows that link a deleted ${model} failed, so its deletes tell every subscribed scope of its via lists, as for a row nobody can place`,
+    { category: "quickdraw.writes", model, junction }
+  );
 }
-function nestedKey(value) {
-  if (!isPlainObject(value)) {
+async function readLinks(runtime, model, ids) {
+  const links = runtime.linksOf(model);
+  if (links.length === 0 || ids.length === 0) {
     return void 0;
   }
-  return NESTED_KEYS.find((key) => writesRelation(value, key));
-}
-function findNestedWrites(data) {
-  if (!isPlainObject(data)) {
-    return [];
-  }
-  const found = [];
-  for (const [field, value] of Object.entries(data)) {
-    const operation = nestedKey(value);
-    if (operation !== void 0) {
-      found.push({ field, operation });
+  const byId = new Map(
+    ids.map((id) => [id, Object.fromEntries(links.map((link) => [link.model, []]))])
+  );
+  for (const link of links) {
+    const select = Object.fromEntries(
+      [link.entry, ...link.columns].map((column) => [column, true])
+    );
+    let delegate;
+    try {
+      delegate = runtime.delegate(link.model);
+    } catch {
+      warnUnread(runtime, model, link.model);
+      return void 0;
+    }
+    let rows;
+    try {
+      rows = await quietly(
+        () => delegate.findMany({ where: { [link.entry]: { in: [...ids] } }, select })
+      );
+    } catch (error) {
+      if (error instanceof Error && error.name === "PrismaClientValidationError") {
+        warnUnread(runtime, model, link.model);
+        return void 0;
+      }
+      throw error;
+    }
+    for (const row of rows) {
+      const entry = row[link.entry];
+      if (typeof entry === "string") {
+        byId.get(entry)?.[link.model]?.push(row);
+      }
     }
   }
-  return found;
+  return byId;
+}
+function withLinks(writes, links) {
+  return writes.map((write) => {
+    const own = links?.get(write.id);
+    return own === void 0 ? write : { ...write, links: own };
+  });
 }
 
 // src/prisma/operations.ts
@@ -131,14 +140,19 @@ function countOwn(op, operation, args) {
   op.runtime.tracker.observe({ model: op.model, operation, args });
 }
 function warnNested(op, data) {
-  for (const { field, operation } of findNestedWrites(data)) {
+  const nested = findNestedWrites(data);
+  for (const { field, operation } of nested) {
     op.runtime.tracker.warn({
       kind: "nested-write",
       subject: `${op.model}.${field}.${operation}`,
-      message: `A nested write (${op.model}.${field}: { ${operation} }) is not tracked; only the ${op.model} row is. Write related rows through their own model`,
+      message: `A nested write (${op.model}.${field}: { ${operation} }) is not tracked: the related rows it creates, changes or deletes send no frames and revoke nothing. The ${op.model} row is tracked, and an update of it reads its access and scope columns first, so a foreign key a to-one connect or disconnect sets on it is seen. Write related rows through their own model, or set the foreign key column`,
       meta: { model: op.model, field, operation }
     });
   }
+  return nested.length > 0;
+}
+function withColumns(data, columns) {
+  return [.../* @__PURE__ */ new Set([...keysOf(data), ...columns])];
 }
 function touchedInterest(op, data) {
   const keys = new Set(keysOf(data));
@@ -289,12 +303,13 @@ async function upsert(op) {
     return upsertWithoutUpdate(op);
   }
   warnNested(op, op.args.create);
-  warnNested(op, op.args.update);
-  const touched = touchedInterest(op, op.args.update);
+  const nested = warnNested(op, op.args.update);
+  const touched = nested ? [...op.runtime.interestOf(op.model)] : touchedInterest(op, op.args.update);
   const before = touched.length === 0 ? void 0 : await readBefore(op, op.args.where, touched, { unique: true });
   const { result, rows } = await runWidened(op);
   if (before !== void 0 && before.size > 0) {
-    record(op, writesOf(op, "update", rows, keysOf(op.args.update), before));
+    const fields = nested ? withColumns(op.args.update, touched) : keysOf(op.args.update);
+    record(op, writesOf(op, "update", rows, fields, before));
   } else if (before === void 0) {
     const writes = writesOf(op, "create", rows, keysOf([op.args.create, op.args.update]));
     record(
@@ -310,16 +325,27 @@ async function update(op) {
   if (writesNothing(op.args.data)) {
     return op.query(op.args);
   }
-  warnNested(op, op.args.data);
-  const touched = touchedInterest(op, op.args.data);
+  const nested = warnNested(op, op.args.data);
+  const touched = nested ? [...op.runtime.interestOf(op.model)] : touchedInterest(op, op.args.data);
   const before = touched.length === 0 ? void 0 : await readBefore(op, op.args.where, touched, { unique: true });
   const { result, rows } = await runWidened(op);
-  record(op, writesOf(op, "update", rows, keysOf(op.args.data), before));
+  const fields = nested ? withColumns(op.args.data, touched) : keysOf(op.args.data);
+  record(op, writesOf(op, "update", rows, fields, before));
   return result;
 }
+async function linksOfDelete(op) {
+  if (op.runtime.linksOf(op.model).length === 0) {
+    return void 0;
+  }
+  warnBatchRead(op);
+  const { where } = op.args;
+  const ids = isRecord(where) && typeof where.id === "string" ? [where.id] : [...(await readBefore(op, where, [], { unique: true })).keys()];
+  return await readLinks(op.runtime, op.model, ids);
+}
 async function remove(op) {
+  const links = await linksOfDelete(op);
   const { result, rows } = await runWidened(op);
-  record(op, writesOf(op, "delete", rows, []));
+  record(op, withLinks(writesOf(op, "delete", rows, []), links));
   return result;
 }
 async function createManyAndReturn(op) {
@@ -401,10 +427,11 @@ async function deleteMany(op) {
   const interest = op.runtime.interestOf(op.model);
   const before = await readBefore(op, where, interest, { unique: false, take: limit });
   const ids = [...before.keys()];
+  const links = await readLinks(op.runtime, op.model, ids);
   const args = limit === void 0 ? op.args : { ...op.args, where: { AND: [where ?? {}, { id: { in: ids } }] } };
   const result = await op.query(args);
   const rows = ids.map((id) => ({ id, ...before.get(id) }));
-  record(op, writesOf(op, "delete", rows, []));
+  record(op, withLinks(writesOf(op, "delete", rows, []), links));
   return result;
 }
 var WRITE_OPERATIONS = Object.freeze({
@@ -434,6 +461,143 @@ function delegates(runtime, operation, args) {
   }
 }
 
+// src/prisma/schemaText.ts
+var BLOCK_START = /^(\w+)\s+([A-Za-z_]\w*)\s*\{/;
+var FIELD = /^([A-Za-z_]\w*)\s+([A-Za-z_]\w*)(\([^)]*\))?(\[\])?(\?)?(?=\s|$)/;
+var IGNORED = /(?:^|\s)@ignore(?=\s|$|\()/;
+var KEY_TYPES = /* @__PURE__ */ new Set(["String", "Int", "BigInt", "Float"]);
+var COLUMN_KINDS = /* @__PURE__ */ new Set(["scalar", "enum"]);
+function isObject(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function withoutComment(line) {
+  let inString = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === '"' && line[index - 1] !== "\\") {
+      inString = !inString;
+    } else if (!inString && char === "/" && line[index + 1] === "/") {
+      return line.slice(0, index);
+    }
+  }
+  return line;
+}
+function blocksOf(text) {
+  const blocks = [];
+  let open;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = withoutComment(raw).trim();
+    if (line === "") {
+      continue;
+    }
+    if (open !== void 0) {
+      if (line === "}") {
+        open = void 0;
+      } else {
+        open.lines.push(line);
+      }
+      continue;
+    }
+    const start = BLOCK_START.exec(line);
+    if (start !== null) {
+      const block = { kind: start[1] ?? "", name: start[2] ?? "", lines: [] };
+      blocks.push(block);
+      open = line.slice(start[0].length).trim() === "}" ? void 0 : block;
+    }
+  }
+  return blocks;
+}
+function kindsOf(runtimeDataModel, model) {
+  const models = isObject(runtimeDataModel) ? Reflect.get(runtimeDataModel, "models") : void 0;
+  const entry = isObject(models) && Object.hasOwn(models, model) ? Reflect.get(models, model) : void 0;
+  const fields = isObject(entry) ? Reflect.get(entry, "fields") : void 0;
+  if (!Array.isArray(fields)) {
+    return void 0;
+  }
+  const kinds = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    const name = isObject(field) ? Reflect.get(field, "name") : void 0;
+    const kind = isObject(field) ? Reflect.get(field, "kind") : void 0;
+    if (typeof name === "string" && typeof kind === "string") {
+      kinds.set(name, kind);
+    }
+  }
+  return kinds;
+}
+function isColumn(name, type, kinds, records) {
+  if (kinds !== void 0) {
+    return COLUMN_KINDS.has(kinds.get(name) ?? "");
+  }
+  return type !== "Unsupported" && !records.has(type);
+}
+function trackableOf(fields, kinds, enums) {
+  const id = fields.get("id");
+  if (id === void 0) {
+    return kinds !== void 0 && COLUMN_KINDS.has(kinds.get("id") ?? "") ? void 0 : false;
+  }
+  if (id.optional || id.list) {
+    return void 0;
+  }
+  return KEY_TYPES.has(id.type) || enums.has(id.type) ? true : void 0;
+}
+function modelOf(block, kinds, records, enums) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of block.lines) {
+    const field = FIELD.exec(line);
+    const [, name = "", type = "", , list, optional] = field ?? [];
+    if (field !== null && !IGNORED.test(line) && isColumn(name, type, kinds, records)) {
+      fields.set(name, { type, optional: optional !== void 0, list: list !== void 0 });
+    }
+  }
+  return { fields, trackable: trackableOf(fields, kinds, enums) };
+}
+function parsePrismaSchema(text, runtimeDataModel) {
+  const blocks = blocksOf(text);
+  const named = (...kinds) => new Set(blocks.filter((block) => kinds.includes(block.kind)).map((block) => block.name));
+  const enums = named("enum");
+  const records = named("model", "view", "type");
+  const models = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const ignored = block.lines.some((line) => /^@@ignore\b/.test(line));
+    if ((block.kind === "model" || block.kind === "view") && !ignored) {
+      const kinds = kindsOf(runtimeDataModel, block.name);
+      models.set(modelKey(block.name), modelOf(block, kinds, records, enums));
+    }
+  }
+  return Object.freeze({
+    nullable(model, column) {
+      const field = models.get(modelKey(model))?.fields.get(column);
+      return field === void 0 ? void 0 : field.optional && !field.list;
+    },
+    trackable: (model) => models.get(modelKey(model))?.trackable
+  });
+}
+function schemaTextOf(client) {
+  try {
+    const config = isObject(client) ? Reflect.get(client, "_engineConfig") : void 0;
+    const text = isObject(config) ? Reflect.get(config, "inlineSchema") : void 0;
+    return typeof text === "string" && text !== "" ? text : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function runtimeDataModelOf(client) {
+  try {
+    const own = isObject(client) ? Reflect.get(client, "_runtimeDataModel") : void 0;
+    if (own !== void 0) {
+      return own;
+    }
+    const config = isObject(client) ? Reflect.get(client, "_engineConfig") : void 0;
+    return isObject(config) ? Reflect.get(config, "runtimeDataModel") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function prismaSchemaOf(client) {
+  const text = schemaTextOf(client);
+  return text === void 0 ? void 0 : parsePrismaSchema(text, runtimeDataModelOf(client));
+}
+
 // src/prisma/trackPrisma.ts
 function isClient(value) {
   return (typeof value === "object" || typeof value === "function") && value !== null && typeof Reflect.get(value, "$extends") === "function";
@@ -487,9 +651,13 @@ async function transaction(tracker, hooked, arg, options) {
     throw error;
   }
 }
-function createNullability(delegate) {
+function createNullability(delegate, schema) {
   const known = /* @__PURE__ */ new Map();
   return async (model, column) => {
+    const declared = schema?.nullable(model, column);
+    if (declared !== void 0) {
+      return declared;
+    }
     const key = `${modelKey(model)}\0${column}`;
     const kept = known.get(key);
     if (kept !== void 0) {
@@ -508,7 +676,38 @@ function createNullability(delegate) {
     return nullable;
   };
 }
-function createStorage(tracker, interest, delegate) {
+function createTrackability(delegate, schema) {
+  const known = /* @__PURE__ */ new Map();
+  const probe = async (key) => {
+    try {
+      const rows = await quietly(() => delegate(key).findMany({ select: { id: true }, take: 1 }));
+      const [row] = Array.isArray(rows) ? rows : [];
+      return row === void 0 || idOf(row) !== void 0;
+    } catch (error) {
+      if (error instanceof Error && error.name === "PrismaClientValidationError") {
+        return false;
+      }
+      throw error;
+    }
+  };
+  return async (model) => {
+    const declared = schema?.trackable(model);
+    if (declared !== void 0) {
+      return declared;
+    }
+    const key = modelKey(model);
+    let answer = known.get(key);
+    if (answer === void 0) {
+      answer = probe(key);
+      known.set(key, answer);
+      answer.catch(() => {
+        known.delete(key);
+      });
+    }
+    return await answer;
+  };
+}
+function createStorage(tracker, [interest, links], delegate, schema) {
   return Object.freeze({
     findMany: (model, args = {}) => quietly(() => delegate(modelKey(model)).findMany(args)),
     count: (model, args = {}) => quietly(() => delegate(modelKey(model)).count(args)),
@@ -516,8 +715,11 @@ function createStorage(tracker, interest, delegate) {
     countStatements: tracker.countStatements,
     registerInterest: interest.register,
     interestOf: interest.of,
+    registerLinks: links.register,
+    linksOf: links.of,
     inTransaction: () => tracker.transactionClient() !== void 0 || tracker.inBatch(),
-    nullable: createNullability(delegate),
+    nullable: createNullability(delegate, schema),
+    trackable: createTrackability(delegate, schema),
     unitOfWork: tracker.unitOfWork
   });
 }
@@ -535,7 +737,14 @@ function trackPrisma(client, options = {}) {
   const interest = createInterestRegistry(options.interest);
   let root;
   const delegate = (model) => delegateOf(tracker.transactionClient() ?? root, model);
-  const runtime = { tracker, delegate, interestOf: interest.of, untracked: /* @__PURE__ */ new Set() };
+  const links = createLinkRegistry();
+  const runtime = {
+    tracker,
+    delegate,
+    interestOf: interest.of,
+    linksOf: links.of,
+    untracked: /* @__PURE__ */ new Set()
+  };
   const hooked = client.$extends({
     name: "quickdraw-tracking",
     query: { $allOperations: createHook(runtime) }
@@ -545,7 +754,7 @@ function trackPrisma(client, options = {}) {
     name: "quickdraw-transactions",
     client: {
       $transaction: (arg, txOptions) => transaction(tracker, hooked, arg, txOptions),
-      [STORAGE_KEY]: createStorage(tracker, interest, delegate)
+      [STORAGE_KEY]: createStorage(tracker, [interest, links], delegate, prismaSchemaOf(client))
     }
   });
   return tracked;