graphddb 0.1.1 → 0.2.1

package/dist/{chunk-347U24SB.js → chunk-PWV7JDMR.js}

@@ -525,6 +525,51 @@ var TableMapping = class {
   }
 };
 
+// src/define/param.ts
+function makeParam(kind, literals) {
+  return literals === void 0 ? { kind } : { kind, literals };
+}
+var param = {
+  /** A placeholder for a `string` value. */
+  string() {
+    return makeParam("string");
+  },
+  /** A placeholder for a `number` value. */
+  number() {
+    return makeParam("number");
+  },
+  /**
+   * A placeholder constrained to one of the given literal values. The value
+   * type of the resulting {@link Param} is the **union of the literals**, so it
+   * is preserved precisely in the IR and the inferred definition types.
+   *
+   * @example
+   * ```ts
+   * param.literal('active', 'disabled'); // Param<'active' | 'disabled'>
+   * ```
+   */
+  literal(...values) {
+    return makeParam("literal", values);
+  },
+  /**
+   * A placeholder for an **array** parameter whose elements have the given field
+   * shape. Used by `defineTransaction`'s `tx.forEach(p.<arrayParam>, …)` to bind
+   * each element's fields to `{item.<field>}` templates.
+   *
+   * @example
+   * ```ts
+   * param.array({ userId: param.string(), role: param.string() });
+   * // Param<{ userId: string; role: string }[]>
+   * ```
+   */
+  array(element) {
+    return { kind: "array", element };
+  }
+};
+function isParam(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "string" || value.kind === "number" || value.kind === "literal" || value.kind === "array");
+}
+
 // src/client/lib-dynamodb.ts
 var cached = null;
 async function loadLibDynamoDB() {
@@ -825,20 +870,20 @@ async function executeQuery(docClient, operation) {
   };
   for (let i = 0; i < keyEntries.length; i++) {
     const [attrName, value] = keyEntries[i];
-    const nameAlias = `#k${i}`;
-    const valueAlias = `:k${i}`;
-    exprAttrNames[nameAlias] = attrName;
-    exprAttrValues[valueAlias] = value;
-    conditionParts.push(`${nameAlias} = ${valueAlias}`);
+    const nameAlias2 = `#k${i}`;
+    const valueAlias2 = `:k${i}`;
+    exprAttrNames[nameAlias2] = attrName;
+    exprAttrValues[valueAlias2] = value;
+    conditionParts.push(`${nameAlias2} = ${valueAlias2}`);
   }
   if (operation.rangeCondition) {
     const rc = operation.rangeCondition;
     const idx = keyEntries.length;
-    const nameAlias = `#k${idx}`;
-    const valueAlias = `:k${idx}`;
-    exprAttrNames[nameAlias] = rc.key;
-    exprAttrValues[valueAlias] = rc.value;
-    conditionParts.push(`begins_with(${nameAlias}, ${valueAlias})`);
+    const nameAlias2 = `#k${idx}`;
+    const valueAlias2 = `:k${idx}`;
+    exprAttrNames[nameAlias2] = rc.key;
+    exprAttrValues[valueAlias2] = rc.value;
+    conditionParts.push(`begins_with(${nameAlias2}, ${valueAlias2})`);
   }
   const cmd = new QueryCommand({
     TableName: operation.tableName,
@@ -860,14 +905,290 @@ async function executeQuery(docClient, operation) {
   };
 }
 
+// src/select/cond.ts
+var RAW_COND = /* @__PURE__ */ Symbol.for("graphddb.rawCond");
+function isRawCondition(value) {
+  return typeof value === "object" && value !== null && value[RAW_COND] === true;
+}
+function cond(template, ...parts) {
+  return {
+    [RAW_COND]: true,
+    template,
+    parts
+  };
+}
+function compileRawCondition(raw, allocName, allocValue) {
+  let out = raw.template[0];
+  for (let i = 0; i < raw.parts.length; i++) {
+    const part = raw.parts[i];
+    if (isColumn(part)) {
+      out += allocName(part.name);
+    } else {
+      out += allocValue(part);
+    }
+    out += raw.template[i + 1];
+  }
+  return out;
+}
+function condParamName(index) {
+  return `cond_p${index}`;
+}
+function serializeRawCondition(raw, renderSlot) {
+  const names = {};
+  const values = {};
+  let valueCounter = 0;
+  let paramIndex = 0;
+  const nameAlias2 = (column) => {
+    const alias = `#cr_${column}`;
+    names[alias] = column;
+    return alias;
+  };
+  const valueAlias2 = (value) => {
+    const alias = `:cr${valueCounter++}`;
+    values[alias] = value;
+    return alias;
+  };
+  let out = raw.template[0];
+  for (let i = 0; i < raw.parts.length; i++) {
+    const part = raw.parts[i];
+    if (isColumn(part)) {
+      out += nameAlias2(part.name);
+    } else {
+      const custom = renderSlot?.(part, paramIndex);
+      if (custom !== void 0) {
+        if (isParam(part)) paramIndex++;
+        out += valueAlias2(custom);
+      } else if (isParam(part)) {
+        out += valueAlias2({ $param: condParamName(paramIndex++) });
+      } else if (part instanceof Date) {
+        out += valueAlias2(part.toISOString());
+      } else {
+        out += valueAlias2(part);
+      }
+    }
+    out += raw.template[i + 1];
+  }
+  return { expression: out, names, values };
+}
+function collectRawConditionParams(raw) {
+  const out = [];
+  let paramIndex = 0;
+  for (const part of raw.parts) {
+    if (isColumn(part)) continue;
+    if (isParam(part)) {
+      out.push({ name: condParamName(paramIndex++), param: part });
+    }
+  }
+  return out;
+}
+
 // src/expression/condition-expression.ts
+var OPERATOR_KEYS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "ge",
+  "lt",
+  "le",
+  "between",
+  "in",
+  "beginsWith",
+  "contains",
+  "notContains",
+  "attributeExists",
+  "attributeType",
+  "size"
+]);
+function nameAlias(ctx, field) {
+  const alias = `#cond_${field}`;
+  ctx.names[alias] = field;
+  return alias;
+}
+function valueAlias(ctx, value) {
+  const alias = `:cond${ctx.valueCounter.n++}`;
+  ctx.values[alias] = value;
+  return alias;
+}
+function isOperatorObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array || value instanceof Set) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0) return false;
+  return keys.every((k2) => OPERATOR_KEYS.has(k2));
+}
+function joinAnd(clauses) {
+  if (clauses.length === 1) return clauses[0];
+  return clauses.map((c) => wrap(c)).join(" AND ");
+}
+function wrap(expr) {
+  if (isAlreadyWrapped(expr)) return expr;
+  if (expr.includes(" AND ") || expr.includes(" OR ")) return `(${expr})`;
+  return expr;
+}
+function isAlreadyWrapped(expr) {
+  if (!expr.startsWith("(") || !expr.endsWith(")")) return false;
+  let depth = 0;
+  for (let i = 0; i < expr.length; i++) {
+    if (expr[i] === "(") depth++;
+    else if (expr[i] === ")") {
+      depth--;
+      if (depth === 0 && i < expr.length - 1) return false;
+    }
+  }
+  return depth === 0;
+}
+function compileField(ctx, field, condition) {
+  const n = nameAlias(ctx, field);
+  if (!isOperatorObject(condition)) {
+    return `${n} = ${valueAlias(ctx, condition)}`;
+  }
+  const ops = condition;
+  const clauses = [];
+  for (const [op, value] of Object.entries(ops)) {
+    switch (op) {
+      case "eq":
+        clauses.push(`${n} = ${valueAlias(ctx, value)}`);
+        break;
+      case "ne":
+        clauses.push(`${n} <> ${valueAlias(ctx, value)}`);
+        break;
+      case "gt":
+        clauses.push(`${n} > ${valueAlias(ctx, value)}`);
+        break;
+      case "ge":
+        clauses.push(`${n} >= ${valueAlias(ctx, value)}`);
+        break;
+      case "lt":
+        clauses.push(`${n} < ${valueAlias(ctx, value)}`);
+        break;
+      case "le":
+        clauses.push(`${n} <= ${valueAlias(ctx, value)}`);
+        break;
+      case "between": {
+        const [lo, hi] = value;
+        clauses.push(
+          `${n} BETWEEN ${valueAlias(ctx, lo)} AND ${valueAlias(ctx, hi)}`
+        );
+        break;
+      }
+      case "in": {
+        const aliases = value.map((v) => valueAlias(ctx, v));
+        clauses.push(`${n} IN (${aliases.join(", ")})`);
+        break;
+      }
+      case "beginsWith":
+        clauses.push(`begins_with(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "contains":
+        clauses.push(`contains(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "notContains":
+        clauses.push(`NOT contains(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "attributeExists":
+        clauses.push(
+          value === false ? `attribute_not_exists(${n})` : `attribute_exists(${n})`
+        );
+        break;
+      case "attributeType":
+        clauses.push(`attribute_type(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "size":
+        clauses.push(`size(${n}) = ${valueAlias(ctx, value)}`);
+        break;
+      default:
+        throw new Error(`Unknown condition operator '${op}' on field '${field}'`);
+    }
+  }
+  return joinAnd(clauses);
+}
+function compileRaw(ctx, raw) {
+  return compileRawCondition(
+    raw,
+    (column) => nameAlias(ctx, column),
+    (value) => valueAlias(ctx, value)
+  );
+}
+function compileNode(ctx, node) {
+  if (isRawCondition(node)) {
+    return compileRaw(ctx, node);
+  }
+  const clauses = [];
+  for (const [key2, value] of Object.entries(node)) {
+    if (value === void 0) continue;
+    if (key2 === "and" || key2 === "or") {
+      const parts = value.map((sub) => compileNode(ctx, sub)).filter((s) => s.length > 0);
+      if (parts.length === 0) continue;
+      if (parts.length === 1) {
+        clauses.push(parts[0]);
+      } else {
+        const sep = key2 === "and" ? " AND " : " OR ";
+        clauses.push(`(${parts.map((p) => wrap(p)).join(sep)})`);
+      }
+      continue;
+    }
+    if (key2 === "not") {
+      const inner = compileNode(ctx, value);
+      if (inner.length > 0) clauses.push(`NOT ${wrap(inner)}`);
+      continue;
+    }
+    const clause = compileField(ctx, key2, value);
+    if (clause.length > 0) clauses.push(clause);
+  }
+  return joinAnd(clauses);
+}
+function resolveConditionTree(declarative, resolveParam) {
+  return resolveNode(declarative, resolveParam);
+}
+function isParamLeaf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.$param === "string";
+}
+function resolveLeaf(value, resolveParam) {
+  if (isParamLeaf(value)) return resolveParam(value.$param);
+  return value;
+}
+function resolveNode(node, resolveParam) {
+  const obj = node;
+  const out = {};
+  for (const [key2, value] of Object.entries(obj)) {
+    if (key2 === "and" || key2 === "or") {
+      out[key2] = value.map((s) => resolveNode(s, resolveParam));
+    } else if (key2 === "not") {
+      out[key2] = resolveNode(value, resolveParam);
+    } else {
+      const ops = value;
+      const rendered = {};
+      for (const [op, opVal] of Object.entries(ops)) {
+        if (op === "between") {
+          const [lo, hi] = opVal;
+          rendered[op] = [
+            resolveLeaf(lo, resolveParam),
+            resolveLeaf(hi, resolveParam)
+          ];
+        } else if (op === "in") {
+          rendered[op] = opVal.map(
+            (v) => resolveLeaf(v, resolveParam)
+          );
+        } else if (op === "attributeExists") {
+          rendered[op] = opVal;
+        } else {
+          rendered[op] = resolveLeaf(opVal, resolveParam);
+        }
+      }
+      out[key2] = rendered;
+    }
+  }
+  return out;
+}
 function buildConditionExpression(condition) {
+  if (isRawCondition(condition)) {
+    const ctx2 = { names: {}, values: {}, valueCounter: { n: 0 } };
+    const expression2 = compileRaw(ctx2, condition);
+    return { expression: expression2, names: ctx2.names, values: ctx2.values };
+  }
   if (condition.notExists === true) {
-    return {
-      expression: "attribute_not_exists(PK)",
-      names: {},
-      values: {}
-    };
+    return { expression: "attribute_not_exists(PK)", names: {}, values: {} };
   }
   if (typeof condition.attributeExists === "string") {
     const field = condition.attributeExists;
@@ -887,22 +1208,9 @@ function buildConditionExpression(condition) {
       values: {}
     };
   }
-  const clauses = [];
-  const names = {};
-  const values = {};
-  let counter = 0;
-  for (const [fieldName, value] of Object.entries(condition)) {
-    const nameKey = `#cond_${fieldName}`;
-    const valueKey = `:cond${counter++}`;
-    names[nameKey] = fieldName;
-    values[valueKey] = value;
-    clauses.push(`${nameKey} = ${valueKey}`);
-  }
-  return {
-    expression: clauses.join(" AND "),
-    names,
-    values
-  };
+  const ctx = { names: {}, values: {}, valueCounter: { n: 0 } };
+  const expression = compileNode(ctx, condition);
+  return { expression, names: ctx.names, values: ctx.values };
 }
 
 // src/operations/serialize.ts
@@ -1719,17 +2027,17 @@ var TransactionContext = class {
     this.assertWithinLimit();
     const modelClass = resolveModelClass(model);
     const { TableName, Key } = buildDeleteInput(modelClass, key2);
-    const cond = buildConditionExpression(options.condition);
+    const cond2 = buildConditionExpression(options.condition);
     const check = {
       TableName,
       Key,
-      ConditionExpression: cond.expression
+      ConditionExpression: cond2.expression
     };
-    if (Object.keys(cond.names).length > 0) {
-      check.ExpressionAttributeNames = cond.names;
+    if (Object.keys(cond2.names).length > 0) {
+      check.ExpressionAttributeNames = cond2.names;
     }
-    if (Object.keys(cond.values).length > 0) {
-      check.ExpressionAttributeValues = cond.values;
+    if (Object.keys(cond2.values).length > 0) {
+      check.ExpressionAttributeValues = cond2.values;
     }
     this.items.push({ ConditionCheck: check });
   }
@@ -1791,10 +2099,18 @@ export {
   pkTemplate,
   skTemplate,
   resolveSegmentedKey,
+  param,
+  isParam,
   BATCH_GET_MAX_KEYS,
   BATCH_WRITE_MAX_ITEMS,
   DynamoExecutor,
   ClientManager,
+  isRawCondition,
+  cond,
+  compileRawCondition,
+  serializeRawCondition,
+  collectRawConditionParams,
+  resolveConditionTree,
   buildConditionExpression,
   serializeFieldValue,
   ChangeCaptureRegistry,

package/dist/{chunk-UNRQ5YJT.js → chunk-SBNP62H7.js}

@@ -1,7 +1,7 @@
 import {
   ChangeCaptureRegistry,
   resolveModelClass
-} from "./chunk-347U24SB.js";
+} from "./chunk-PWV7JDMR.js";
 
 // src/cdc/prng.ts
 var SeededRandom = class {

package/dist/cli.js

@@ -2,10 +2,10 @@
 import {
   buildBridgeBundle,
   normalizeSelectSpec
-} from "./chunk-6LEHSX45.js";
+} from "./chunk-4B4MUPUJ.js";
 import {
   MetadataRegistry
-} from "./chunk-347U24SB.js";
+} from "./chunk-PWV7JDMR.js";
 
 // src/cli.ts
 import { createRequire } from "module";