graphddb 0.4.2 → 0.5.0

package/dist/{chunk-BROCT574.js → chunk-7NPG5R7O.js}

@@ -7,7 +7,7 @@ import {
   buildMaintenanceGraph,
   buildPutInput,
   resolveModelClass
-} from "./chunk-CPTV3H2U.js";
+} from "./chunk-FMJIWFIS.js";
 
 // src/cdc/prng.ts
 var SeededRandom = class {

package/dist/{chunk-CPTV3H2U.js → chunk-FMJIWFIS.js}

@@ -412,6 +412,21 @@ var relationDepthRule = {
   }
 };
 
+// src/client/TableMapping.ts
+var TableMapping = class {
+  static mapping = {};
+  static set(mapping) {
+    this.mapping = { ...mapping };
+  }
+  static resolve(declaredName) {
+    return this.mapping[declaredName] ?? declaredName;
+  }
+  /** @internal — for testing only */
+  static reset() {
+    this.mapping = {};
+  }
+};
+
 // src/linter/rules/same-partition-preset.ts
 var samePartitionPresetRule = {
   id: "same-partition-preset",
@@ -843,6 +858,112 @@ function destinationRowKey(owner, relation) {
   return `${owner}#${parts.join("&")}`;
 }
 
+// src/linter/rules/cfn-schema-consistency.ts
+var MAX_GSIS_PER_TABLE = 20;
+function gsiShape(gsi2) {
+  const hasSk = gsi2.segmented.skSegments.length > 0;
+  return { indexName: gsi2.indexName, hasSk };
+}
+function err3(entity, message) {
+  return {
+    ruleId: "cfn-schema-consistency",
+    severity: "error",
+    message,
+    entity
+  };
+}
+var cfnSchemaConsistencyRule = {
+  id: "cfn-schema-consistency",
+  severity: "error",
+  check(metadata, registry) {
+    return checkAllTables(metadata, registry);
+  }
+};
+function checkAllTables(current, registry) {
+  const seenMeta = /* @__PURE__ */ new Set();
+  const byPhysical = /* @__PURE__ */ new Map();
+  const add = (meta) => {
+    if (seenMeta.has(meta)) return;
+    seenMeta.add(meta);
+    const physical = TableMapping.resolve(meta.tableName);
+    const list = byPhysical.get(physical) ?? [];
+    list.push(meta);
+    byPhysical.set(physical, list);
+  };
+  add(current);
+  for (const [, meta] of registry.getFinalized()) add(meta);
+  const currentPhysical = TableMapping.resolve(current.tableName);
+  const entities = byPhysical.get(currentPhysical);
+  if (!entities) return [];
+  return checkTable(currentPhysical, entities);
+}
+function checkTable(physical, entities) {
+  const ordered = [...entities].sort((a, b) => a.prefix.localeCompare(b.prefix));
+  const results = [];
+  results.push(...checkBaseKeySchema(physical, ordered));
+  results.push(...checkGsiUnion(physical, ordered));
+  return results;
+}
+function checkBaseKeySchema(physical, entities) {
+  const withSk = [];
+  const withoutSk = [];
+  for (const meta of entities) {
+    if (!meta.primaryKey) continue;
+    const hasSk = meta.primaryKey.segmented.skSegments.length > 0;
+    (hasSk ? withSk : withoutSk).push(meta.prefix);
+  }
+  if (withSk.length > 0 && withoutSk.length > 0) {
+    const offender = [...withSk, ...withoutSk].sort()[0];
+    return [
+      err3(
+        offender,
+        `CloudFormation schema consistency: physical table '${physical}' has an ambiguous base KeySchema \u2014 some entities declare a sort key and some do not (with SK: [${withSk.join(", ")}]; without SK: [${withoutSk.join(", ")}]). A single DynamoDB table has exactly one KeySchema; every entity sharing a table must agree on whether the base key has an SK.`
+      )
+    ];
+  }
+  return [];
+}
+function checkGsiUnion(physical, entities) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const meta of entities) {
+    for (const gsi2 of meta.gsiDefinitions) {
+      const shape = gsiShape(gsi2);
+      const existing = seen.get(shape.indexName);
+      if (!existing) {
+        seen.set(shape.indexName, { shape, entity: meta.prefix });
+        continue;
+      }
+      const conflict = describeConflict(existing.shape, shape);
+      if (conflict) {
+        results.push(
+          err3(
+            meta.prefix,
+            `CloudFormation schema consistency: GSI '${shape.indexName}' on physical table '${physical}' is declared inconsistently across entities that share it \u2014 ${conflict} (first declared by '${existing.entity}', conflicting declaration on '${meta.prefix}'). A single DynamoDB table has exactly one GSI per index name; entities may share an index name (projecting different logical fields into the shared physical key), but only when its physical key structure (sort-key presence) is identical.`
+          )
+        );
+      }
+    }
+  }
+  if (seen.size > MAX_GSIS_PER_TABLE) {
+    const names = [...seen.keys()].sort();
+    const offender = [...entities].map((e) => e.prefix).sort()[0];
+    results.push(
+      err3(
+        offender,
+        `CloudFormation schema consistency: physical table '${physical}' would have ${seen.size} global secondary indexes after unioning across entities, exceeding the DynamoDB limit of ${MAX_GSIS_PER_TABLE}. Distinct index names: [${names.join(", ")}]. Reduce the number of distinct GSIs on this table.`
+      )
+    );
+  }
+  return results;
+}
+function describeConflict(a, b) {
+  if (a.hasSk !== b.hasSk) {
+    return `one declaration has a sort key and the other does not (${a.hasSk ? "with" : "without"} SK vs. ${b.hasSk ? "with" : "without"} SK)`;
+  }
+  return null;
+}
+
 // src/linter/default-linter.ts
 function createDefaultLinter() {
   const linter = new Linter();
@@ -857,6 +978,7 @@ function createDefaultLinter() {
   linter.addRule(hotPartitionRule);
   linter.addRule(fanOutRule);
   linter.addRule(multiMaintainerSameRowRule);
+  linter.addRule(cfnSchemaConsistencyRule);
   return linter;
 }
 
@@ -909,6 +1031,25 @@ var MetadataRegistry = class {
     }
     return new Map(this.store);
   }
+  /**
+   * Snapshot of the entities that are **already finalized**, WITHOUT triggering
+   * finalize on any pending entity (unlike {@link getAll}). This is the safe view
+   * for a cross-entity lint rule that runs *inside* `finalize`: eagerly
+   * finalizing the rest of the registry from within a finalize pass would
+   * re-enter (and duplicate) the in-progress entity's finalize. A whole-registry
+   * rule instead reasons over the already-finalized peers plus the entity
+   * currently being checked; any conflicting pair is caught when the later of the
+   * two finalizes (both are present by then).
+   *
+   * @internal — for cross-entity linter rules.
+   */
+  static getFinalized() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [target, meta] of this.store) {
+      if (meta._finalized) out.set(target, meta);
+    }
+    return out;
+  }
   static get linter() {
     return this._linter;
   }
@@ -968,21 +1109,6 @@ ${messages}`);
   }
 };
 
-// src/client/TableMapping.ts
-var TableMapping = class {
-  static mapping = {};
-  static set(mapping) {
-    this.mapping = { ...mapping };
-  }
-  static resolve(declaredName) {
-    return this.mapping[declaredName] ?? declaredName;
-  }
-  /** @internal — for testing only */
-  static reset() {
-    this.mapping = {};
-  }
-};
-
 // src/define/param.ts
 function isParamOptions(value) {
   return typeof value === "object" && value !== null;
@@ -2334,14 +2460,14 @@ var MiddlewareRuntime = class {
    * is the host's responsibility — a hook recovering a `query` should return an
    * item / `null`, one recovering a `list` a `{ items, cursor }`.
    */
-  async runRequestError(ctx, err3) {
+  async runRequestError(ctx, err4) {
     for (let i = this.chain.length - 1; i >= 0; i--) {
       const onError = this.chain[i].read?.onError;
       if (!onError) continue;
-      const recovered = await onError(ctx, err3);
+      const recovered = await onError(ctx, err4);
       if (recovered !== void 0) return recovered;
     }
-    throw err3;
+    throw err4;
   }
   /**
    * Drive ONE physical op (root read or any fan-out fetch) through R2 → send →
@@ -2381,14 +2507,14 @@ var MiddlewareRuntime = class {
         if (afterFetch) items = await afterFetch(ctx, items);
       }
       return items;
-    } catch (err3) {
+    } catch (err4) {
       for (let i = this.chain.length - 1; i >= 0; i--) {
         const onError = this.chain[i].read?.op?.onError;
         if (!onError) continue;
-        const recovered = await onError(ctx, err3);
+        const recovered = await onError(ctx, err4);
         if (recovered !== void 0) return recovered;
       }
-      throw err3;
+      throw err4;
     }
   }
 };
@@ -2452,14 +2578,14 @@ var WriteRuntime = class {
    * short-circuits the chain); the value becomes the write's resolved value.
    * Otherwise the original error rethrows (symmetric with the read `onError`).
    */
-  async runWriteError(ctx, err3) {
+  async runWriteError(ctx, err4) {
     for (let i = this.chain.length - 1; i >= 0; i--) {
       const onError = this.chain[i].write?.onError;
       if (!onError) continue;
-      const recovered = await onError(ctx, err3);
+      const recovered = await onError(ctx, err4);
       if (recovered !== void 0) return recovered;
     }
-    throw err3;
+    throw err4;
   }
   /** Build a W3/W4/W5 persist context (pure — no hooks run). */
   persistCtx(items, origins, transaction) {
@@ -2488,20 +2614,20 @@ var WriteRuntime = class {
         if (before) await before(ctx);
       }
       results = await send(ctx.items);
-    } catch (err3) {
+    } catch (err4) {
       let recovered;
       let didRecover = false;
       for (let i = this.chain.length - 1; i >= 0; i--) {
         const onError = this.chain[i].write?.persist?.onError;
         if (!onError) continue;
-        const r = await onError(ctx, err3);
+        const r = await onError(ctx, err4);
         if (r !== void 0) {
           recovered = r;
           didRecover = true;
           break;
         }
       }
-      if (!didRecover) throw err3;
+      if (!didRecover) throw err4;
       results = recovered;
     }
     for (let i = this.chain.length - 1; i >= 0; i--) {
@@ -2722,8 +2848,8 @@ async function executeSingleWriteWithHooks(req, mw) {
     await mw.runWriteBefore(ctx);
     const change2 = await persistRewrittenWrite(req.modelClass, ctx, mw);
     await mw.runWriteAfter(ctx, change2);
-  } catch (err3) {
-    await mw.runWriteError(ctx, err3);
+  } catch (err4) {
+    await mw.runWriteError(ctx, err4);
   }
 }
 async function persistRewrittenWrite(modelClass, ctx, mw) {
@@ -4287,9 +4413,9 @@ export {
   resolveKey,
   missingGsiRule,
   relationDepthRule,
+  TableMapping,
   createDefaultLinter,
   MetadataRegistry,
-  TableMapping,
   pkTemplate,
   skTemplate,
   resolveSegmentedKey,

package/dist/{chunk-G5RWWBAL.js → chunk-J5A665UW.js}

@@ -42,7 +42,7 @@ import {
   serializeFieldValue,
   serializeRawCondition,
   skTemplate
-} from "./chunk-CPTV3H2U.js";
+} from "./chunk-FMJIWFIS.js";
 
 // src/spec/types.ts
 var SPEC_VERSION = "1.0";
@@ -129,7 +129,11 @@ function buildEntity(metadata) {
     key: buildKey(metadata.primaryKey),
     gsis: buildGsis(metadata),
     relations: buildRelations(metadata),
-    ...metadata.description !== void 0 ? { description: metadata.description } : {}
+    ...metadata.description !== void 0 ? { description: metadata.description } : {},
+    // TTL (issue #172, Epic #167 — C4): a physical-schema fact carried on the
+    // manifest so the CFn emitter can render `TimeToLiveSpecification`. Absent
+    // when no `@ttl` field is declared (byte-identical to the pre-#172 manifest).
+    ...metadata.ttlAttribute !== void 0 ? { ttlAttribute: metadata.ttlAttribute } : {}
   };
 }
 function buildManifest(registry = MetadataRegistry) {
@@ -140,12 +144,28 @@ function buildManifest(registry = MetadataRegistry) {
   }
   const entities = {};
   const tables = {};
+  const ttlByPhysicalTable = /* @__PURE__ */ new Map();
   for (const name of [...entitiesByName.keys()].sort()) {
     const metadata = entitiesByName.get(name);
     entities[name] = buildEntity(metadata);
+    const physicalName = TableMapping.resolve(metadata.tableName);
     tables[metadata.tableName] = {
-      physicalName: TableMapping.resolve(metadata.tableName)
+      physicalName
     };
+    if (metadata.ttlAttribute !== void 0) {
+      const existing = ttlByPhysicalTable.get(physicalName);
+      if (existing && existing.attr !== metadata.ttlAttribute) {
+        throw new Error(
+          `Manifest build: physical table '${physicalName}' has more than one TTL attribute \u2014 entity '${existing.entity}' declares \`@ttl\` on '${existing.attr}' and entity '${name}' on '${metadata.ttlAttribute}'. DynamoDB allows exactly one TTL attribute per table; align the \`@ttl\` attribute across all entities sharing this table (or drop one).`
+        );
+      }
+      if (!existing) {
+        ttlByPhysicalTable.set(physicalName, {
+          entity: name,
+          attr: metadata.ttlAttribute
+        });
+      }
+    }
   }
   return {
     version: SPEC_VERSION,