qstd 0.2.27 → 0.2.28

package/dist/server/index.js

@@ -1,5 +1,7 @@
 import { format, formatDistanceToNow, formatISO, isSameYear, isSameMonth, isSameDay, addSeconds, addMinutes, addHours, addDays, addWeeks, addBusinessDays, addMonths, addYears } from 'date-fns';
 import { promises } from 'fs';
+import { DynamoDBDocumentClient, ScanCommand, QueryCommand, DeleteCommand, PutCommand, BatchGetCommand, TransactWriteCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBClient, DeleteTableCommand, DescribeTableCommand, DynamoDBServiceException } from '@aws-sdk/client-dynamodb';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -605,8 +607,8 @@ var readFile = async (filePath, encoding = "utf-8") => {
 var writeBufferToFile = async (filepath, buffer) => {
   if (!buffer) return;
   const chunks = [];
-  for await (const chunk2 of buffer) {
-    chunks.push(chunk2);
+  for await (const chunk3 of buffer) {
+    chunks.push(chunk3);
   }
   await promises.writeFile(filepath, Buffer.concat(chunks));
 };
@@ -614,4 +616,600 @@ var writeFile = async (filepath, content) => {
   return promises.writeFile(filepath, content);
 };
 
-export { dict_exports as Dict, file_exports as File, flow_exports as Flow, int_exports as Int, list_exports as List, log_exports as Log, money_exports as Money, random_exports as Random, str_exports as Str, time_exports as Time };
+// src/server/aws/ddb/index.ts
+var ddb_exports = {};
+__export(ddb_exports, {
+  batchDelete: () => batchDelete,
+  batchGet: () => batchGet,
+  batchWrite: () => batchWrite,
+  create: () => create2,
+  deleteTable: () => deleteTable,
+  find: () => find,
+  lsi: () => lsi,
+  lsi2: () => lsi2,
+  lsiNormalized: () => lsiNormalized,
+  lsiPhash: () => lsiPhash,
+  lsiUsername: () => lsiUsername,
+  remove: () => remove,
+  save: () => save,
+  tableExists: () => tableExists
+});
+
+// src/server/aws/ddb/fns.ts
+var validateFindProps = (props) => {
+  const isScan = "scan" in props && props.scan === true;
+  if (!props.tableName) {
+    throw new Error(`[ddb] "tableName" is required`);
+  }
+  if (props.limit && props.recursive) {
+    throw new Error(`[ddb] "limit" and "recursive" cannot be used together`);
+  }
+  if (!isScan) {
+    const queryProps = props;
+    if (!queryProps.pk) {
+      throw new Error(`[ddb] [find] "pk" is required for Query mode. Use scan: true to scan without pk.`);
+    }
+    if (queryProps.sk && "key" in queryProps.sk && queryProps.sk.key && queryProps.sk.key !== "sk" && !queryProps.indexName) {
+      throw new Error(
+        `[ddb] [find] you provided a custom sk but no indexName. If this is a mistake, change this error to a warn.`
+      );
+    }
+  }
+};
+var buildKeyConditionExpression = (pk, sk, names, values) => {
+  const pkKey = pk.key ?? "pk";
+  names["#pk"] = pkKey;
+  values[":pk"] = pk.value;
+  if (!sk) return "#pk = :pk";
+  const skName = sk.key ?? "sk";
+  names["#sk"] = skName;
+  if ("op" in sk && sk.op) {
+    switch (sk.op) {
+      case "=":
+      case ">=":
+      case ">":
+      case "<=":
+      case "<":
+        values[":sk"] = sk.value;
+        return `#pk = :pk AND #sk ${sk.op} :sk`;
+      case "begins_with":
+        values[":sk"] = sk.value;
+        return `#pk = :pk AND begins_with(#sk, :sk)`;
+      case "between": {
+        const [from, to] = sk.value;
+        values[":skFrom"] = from;
+        values[":skTo"] = to;
+        return `#pk = :pk AND #sk BETWEEN :skFrom AND :skTo`;
+      }
+      default:
+        throw new Error(`Unsupported SK op: ${JSON.stringify(sk, null, 2)}`);
+    }
+  }
+  if ("value" in sk && sk.value !== void 0) {
+    values[":sk"] = sk.value;
+    return `#pk = :pk AND #sk = :sk`;
+  }
+  if ("valueBeginsWith" in sk && sk.valueBeginsWith !== void 0) {
+    values[":sk"] = sk.valueBeginsWith;
+    return `#pk = :pk AND begins_with(#sk, :sk)`;
+  }
+  throw new Error(
+    `Invalid SK condition: expected 'op' or legacy 'value'/'valueBeginsWith'`
+  );
+};
+var buildFilterExpression = (filters, names, values) => {
+  if (!filters || filters.length === 0) return void 0;
+  const frags = [];
+  filters.forEach((f, i) => {
+    const nameToken = `#f${i}`;
+    names[nameToken] = f.key;
+    switch (f.op) {
+      case "attribute_exists":
+        frags.push(`attribute_exists(${nameToken})`);
+        break;
+      case "attribute_not_exists":
+        frags.push(`attribute_not_exists(${nameToken})`);
+        break;
+      case "between": {
+        const [lo, hi] = f.value;
+        const loPh = `:f${i}_lo`;
+        const hiPh = `:f${i}_hi`;
+        values[loPh] = lo;
+        values[hiPh] = hi;
+        frags.push(`${nameToken} BETWEEN ${loPh} AND ${hiPh}`);
+        break;
+      }
+      case "in": {
+        const arr = f.value;
+        if (!arr.length) {
+          throw new Error(
+            `'in' filter for ${f.key} requires at least one value`
+          );
+        }
+        const phs = arr.map((_, j) => `:f${i}_${j}`);
+        arr.forEach((v, j) => {
+          const ph = phs[j];
+          if (ph) values[ph] = v;
+        });
+        frags.push(`${nameToken} IN (${phs.join(", ")})`);
+        break;
+      }
+      case "contains":
+      case "begins_with": {
+        const ph = `:f${i}`;
+        values[ph] = f.value;
+        frags.push(`${f.op}(${nameToken}, ${ph})`);
+        break;
+      }
+      case "=":
+      case "<>":
+      case ">":
+      case ">=":
+      case "<":
+      case "<=": {
+        const ph = `:f${i}`;
+        values[ph] = f.value;
+        frags.push(`${nameToken} ${f.op} ${ph}`);
+        break;
+      }
+    }
+  });
+  return frags.join(" AND ");
+};
+var buildProjectionExpression = (projection, names) => {
+  const projectionNames = projection.map((key, idx) => {
+    const nameKey = `#proj${idx}`;
+    names[nameKey] = key;
+    return nameKey;
+  });
+  return projectionNames.join(", ");
+};
+var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var backoffDelay = (attempt) => {
+  return Math.min(1e3 * Math.pow(2, attempt), 1e4);
+};
+var chunk2 = (arr, size) => {
+  return Array.from(
+    { length: Math.ceil(arr.length / size) },
+    (_, i) => arr.slice(i * size, i * size + size)
+  );
+};
+
+// src/server/aws/ddb/domain.ts
+var create2 = (props) => {
+  const tableName = props?.tableName;
+  const credentials = props?.credentials;
+  const client = DynamoDBDocumentClient.from(
+    new DynamoDBClient({
+      ...credentials && { credentials },
+      region: "us-east-1"
+    }),
+    {
+      marshallOptions: {
+        // Whether to automatically convert empty strings, blobs, and sets to `null`.
+        convertEmptyValues: false,
+        // false, by default.
+        // Whether to remove undefined values while marshalling.
+        removeUndefinedValues: false,
+        // false, by default.
+        // Whether to convert typeof object to map attribute.
+        convertClassInstanceToMap: false
+        // false, by default.
+      },
+      unmarshallOptions: {
+        // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
+        wrapNumbers: false
+        // false, by default.
+      }
+    }
+  );
+  return { client, tableName };
+};
+async function find(ddb, props) {
+  try {
+    const TableName = props.tableName ?? ddb.tableName;
+    const { filters, projection, debug } = props;
+    const isScan = "scan" in props && props.scan === true;
+    validateFindProps(props);
+    const names = {};
+    const values = {};
+    const KeyConditionExpression = isScan ? void 0 : buildKeyConditionExpression(
+      props.pk,
+      props.sk,
+      names,
+      values
+    );
+    const FilterExpression = filters ? buildFilterExpression(filters, names, values) : void 0;
+    if (debug) {
+      console.log(`[debug] [ddb] [find] input:`, {
+        isScan,
+        filters,
+        FilterExpression,
+        names,
+        values
+      });
+    }
+    const ProjectionExpression = projection ? buildProjectionExpression(projection, names) : void 0;
+    const all = [];
+    let startKey = props.startKey;
+    let pageCount = 0;
+    let totalItems = 0;
+    do {
+      if (props.maxPages && pageCount >= props.maxPages) break;
+      const command = isScan ? new ScanCommand({
+        TableName,
+        IndexName: props.indexName,
+        FilterExpression,
+        Limit: props.limit,
+        ProjectionExpression,
+        ExclusiveStartKey: startKey,
+        ConsistentRead: props.strong,
+        ...Object.keys(names).length > 0 && {
+          ExpressionAttributeNames: names
+        },
+        ...Object.keys(values).length > 0 && {
+          ExpressionAttributeValues: values
+        }
+      }) : new QueryCommand({
+        TableName,
+        IndexName: props.indexName,
+        KeyConditionExpression,
+        FilterExpression,
+        Limit: props.limit,
+        ProjectionExpression,
+        ExclusiveStartKey: startKey,
+        ConsistentRead: props.strong,
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: values,
+        ScanIndexForward: props.sort === "desc" ? false : true
+      });
+      const result = await ddb.client.send(command);
+      const pageItems = result.Items ?? [];
+      all.push(...pageItems);
+      totalItems += pageItems.length;
+      pageCount++;
+      startKey = result.LastEvaluatedKey;
+      if (props.recursive) {
+        if (props.maxItems && totalItems >= props.maxItems) break;
+        if (!startKey) break;
+        if (typeof props.recursive === "function") {
+          const page = {
+            lastEvaluatedKey: result.LastEvaluatedKey,
+            scannedCount: result.ScannedCount ?? 0,
+            count: result.Count ?? 0,
+            items: pageItems
+          };
+          const shouldContinue = props.recursive(page, pageCount, totalItems);
+          if (!shouldContinue) break;
+        }
+      } else {
+        break;
+      }
+    } while (true);
+    const rawResponse = {
+      lastEvaluatedKey: startKey,
+      scannedCount: totalItems,
+      count: totalItems,
+      items: all
+    };
+    if (props.raw && props.first) {
+      return {
+        count: rawResponse.count,
+        item: rawResponse.items[0],
+        scannedCount: rawResponse.scannedCount
+      };
+    }
+    if (props.raw) return rawResponse;
+    if (props.first) return rawResponse.items[0];
+    return rawResponse.items;
+  } catch (error2) {
+    const err = error2;
+    console.log(`[error] [ddb] [find] failed with ${err.message}. Input:`);
+    console.dir(props, { depth: 100 });
+    throw err;
+  }
+}
+var remove = async (ddb, props) => {
+  const TableName = props.tableName ?? ddb.tableName;
+  const command = new DeleteCommand({ Key: props.key, TableName });
+  return ddb.client.send(command);
+};
+var save = async (ddb, props) => {
+  const TableName = props.tableName ?? ddb.tableName;
+  const command = new PutCommand({
+    Item: props.item,
+    TableName
+  });
+  return ddb.client.send(command);
+};
+async function batchGet(ddb, props) {
+  const { keys, maxRetries = 3, strong = false } = props;
+  const TableName = props.tableName ?? ddb.tableName;
+  const chunks = chunk2(keys, 100);
+  const allItems = [];
+  const requestedCount = keys.length;
+  let totalConsumedCapacity = 0;
+  for (const chunk3 of chunks) {
+    let attempt = 0;
+    let keysToFetch = chunk3;
+    while (keysToFetch.length > 0 && attempt <= maxRetries) {
+      if (attempt > 0) {
+        const delay = backoffDelay(attempt);
+        console.log(
+          `[info] [ddb] [batchGet]: Retrying ${keysToFetch.length} keys (attempt ${attempt}/${maxRetries}) after ${delay}ms`
+        );
+        await sleep3(delay);
+      }
+      try {
+        const command = new BatchGetCommand({
+          RequestItems: {
+            [TableName]: { Keys: keysToFetch, ConsistentRead: strong }
+          }
+        });
+        const result = await ddb.client.send(command);
+        const items = result.Responses?.[TableName] ?? [];
+        allItems.push(...items);
+        if (result.ConsumedCapacity) {
+          totalConsumedCapacity += result.ConsumedCapacity.reduce(
+            (sum, cap) => sum + (cap.CapacityUnits ?? 0),
+            0
+          );
+        }
+        const unprocessed = result.UnprocessedKeys?.[TableName]?.Keys;
+        if (unprocessed && unprocessed.length > 0) {
+          keysToFetch = unprocessed;
+          attempt++;
+        } else {
+          keysToFetch = [];
+        }
+      } catch (error2) {
+        console.log(
+          `[error] [ddb] [batchGet]: Error fetching chunk (attempt ${attempt}/${maxRetries}):`,
+          error2
+        );
+        if (attempt >= maxRetries) throw error2;
+        attempt++;
+      }
+    }
+    if (keysToFetch.length > 0) {
+      console.log(
+        `[error] [ddb] [batchGet]: Failed to fetch ${keysToFetch.length} keys after ${maxRetries} retries`
+      );
+    }
+  }
+  const missing = requestedCount - allItems.length;
+  return {
+    missing,
+    items: allItems,
+    count: allItems.length,
+    consumedCapacity: totalConsumedCapacity || void 0
+  };
+}
+async function batchWrite(ddb, props) {
+  const { maxRetries = 3 } = props;
+  const TableName = props.tableName ?? ddb.tableName;
+  const items = props.transform ? props.items.map(props.transform) : props.items;
+  const hasConditions = items.some((x) => x.cond);
+  const chunkSize = hasConditions ? 100 : 25;
+  const chunks = chunk2(items, chunkSize);
+  let processedCount = 0;
+  let failedCount = 0;
+  let totalConsumedCapacity = 0;
+  for (const chunk3 of chunks) {
+    let attempt = 0;
+    let itemsToWrite = chunk3;
+    while (itemsToWrite.length > 0 && attempt <= maxRetries) {
+      if (attempt > 0) {
+        const delay = backoffDelay(attempt);
+        console.log(
+          `[info] [ddb] [batchWrite]: Retrying ${itemsToWrite.length} items (attempt ${attempt}/${maxRetries}) after ${delay}ms`
+        );
+        await sleep3(delay);
+      }
+      try {
+        if (hasConditions) {
+          const transactItems = itemsToWrite.map((x) => ({
+            Put: {
+              TableName,
+              Item: x.item,
+              ...x.cond && { ConditionExpression: x.cond }
+            }
+          }));
+          const command = new TransactWriteCommand({
+            TransactItems: transactItems
+          });
+          const result = await ddb.client.send(command);
+          if (result.ConsumedCapacity) {
+            totalConsumedCapacity += result.ConsumedCapacity.reduce(
+              (sum, cap) => sum + (cap.CapacityUnits ?? 0),
+              0
+            );
+          }
+          processedCount += itemsToWrite.length;
+          itemsToWrite = [];
+        } else {
+          const writeRequests = itemsToWrite.map((x) => ({
+            PutRequest: { Item: x.item }
+          }));
+          const command = new BatchWriteCommand({
+            RequestItems: { [TableName]: writeRequests }
+          });
+          const result = await ddb.client.send(command);
+          if (result.ConsumedCapacity) {
+            totalConsumedCapacity += result.ConsumedCapacity.reduce(
+              (sum, cap) => sum + (cap.CapacityUnits ?? 0),
+              0
+            );
+          }
+          const unprocessed = result.UnprocessedItems?.[TableName];
+          if (unprocessed && unprocessed.length > 0) {
+            itemsToWrite = unprocessed.map((req) => ({
+              item: req.PutRequest.Item
+            }));
+            processedCount += chunk3.length - itemsToWrite.length;
+            attempt++;
+          } else {
+            processedCount += itemsToWrite.length;
+            itemsToWrite = [];
+          }
+        }
+      } catch (error2) {
+        console.log(
+          `[error] [ddb] [batchWrite]: Error writing chunk (attempt ${attempt}/${maxRetries}):`,
+          error2
+        );
+        if (attempt >= maxRetries) {
+          failedCount += itemsToWrite.length;
+          itemsToWrite = [];
+        } else {
+          attempt++;
+        }
+      }
+    }
+    if (itemsToWrite.length > 0) {
+      console.log(
+        `[error] [ddb] [batchWrite]: Failed to write ${itemsToWrite.length} items after ${maxRetries} retries`
+      );
+      failedCount += itemsToWrite.length;
+    }
+  }
+  return {
+    failed: failedCount,
+    processed: processedCount,
+    consumedCapacity: totalConsumedCapacity || void 0
+  };
+}
+async function batchDelete(ddb, props) {
+  const { maxRetries = 3 } = props;
+  const TableName = props.tableName ?? ddb.tableName;
+  const keys = props.transform ? props.keys.map(props.transform) : props.keys;
+  const hasConditions = keys.some((x) => x.cond);
+  const chunkSize = hasConditions ? 100 : 25;
+  const chunks = chunk2(keys, chunkSize);
+  let processedCount = 0;
+  let failedCount = 0;
+  let totalConsumedCapacity = 0;
+  for (const chunk3 of chunks) {
+    let attempt = 0;
+    let itemsToDelete = chunk3;
+    while (itemsToDelete.length > 0 && attempt <= maxRetries) {
+      if (attempt > 0) {
+        const delay = backoffDelay(attempt);
+        console.log(
+          `[info] [ddb] [batchDelete]: Retrying ${itemsToDelete.length} items (attempt ${attempt}/${maxRetries}) after ${delay}ms`
+        );
+        await sleep3(delay);
+      }
+      try {
+        if (hasConditions) {
+          const transactItems = itemsToDelete.map((x) => ({
+            Delete: {
+              TableName,
+              Key: x.key,
+              ...x.cond && { ConditionExpression: x.cond }
+            }
+          }));
+          const command = new TransactWriteCommand({
+            TransactItems: transactItems
+          });
+          const result = await ddb.client.send(command);
+          if (result.ConsumedCapacity) {
+            totalConsumedCapacity += result.ConsumedCapacity.reduce(
+              (sum, cap) => sum + (cap.CapacityUnits ?? 0),
+              0
+            );
+          }
+          processedCount += itemsToDelete.length;
+          itemsToDelete = [];
+        } else {
+          const writeRequests = itemsToDelete.map((x) => ({
+            DeleteRequest: { Key: x.key }
+          }));
+          const command = new BatchWriteCommand({
+            RequestItems: { [TableName]: writeRequests }
+          });
+          const result = await ddb.client.send(command);
+          if (result.ConsumedCapacity) {
+            totalConsumedCapacity += result.ConsumedCapacity.reduce(
+              (sum, cap) => sum + (cap.CapacityUnits ?? 0),
+              0
+            );
+          }
+          const unprocessed = result.UnprocessedItems?.[TableName];
+          if (unprocessed && unprocessed.length > 0) {
+            itemsToDelete = unprocessed.map((req) => ({
+              key: req.DeleteRequest.Key
+            }));
+            processedCount += chunk3.length - itemsToDelete.length;
+            attempt++;
+          } else {
+            processedCount += itemsToDelete.length;
+            itemsToDelete = [];
+          }
+        }
+      } catch (error2) {
+        console.log(
+          `[error] [ddb] [batchDelete]: Error deleting chunk (attempt ${attempt}/${maxRetries}):`,
+          error2
+        );
+        if (attempt >= maxRetries) {
+          failedCount += itemsToDelete.length;
+          itemsToDelete = [];
+        } else {
+          attempt++;
+        }
+      }
+    }
+    if (itemsToDelete.length > 0) {
+      console.log(
+        `[error] [ddb] [batchDelete]: Failed to delete ${itemsToDelete.length} items after ${maxRetries} retries`
+      );
+      failedCount += itemsToDelete.length;
+    }
+  }
+  return {
+    failed: failedCount,
+    processed: processedCount,
+    consumedCapacity: totalConsumedCapacity || void 0
+  };
+}
+var deleteTable = (ddb, tableName) => {
+  const TableName = tableName;
+  const command = new DeleteTableCommand({ TableName });
+  return ddb.client.send(command);
+};
+var tableExists = async (ddb, props) => {
+  try {
+    const TableName = props.tableName;
+    const command = new DescribeTableCommand({ TableName });
+    await ddb.client.send(command);
+    return true;
+  } catch (err) {
+    if (err instanceof DynamoDBServiceException) {
+      if (err.name === "ResourceNotFoundException" || err.$metadata.httpStatusCode === 400) {
+        return false;
+      }
+    }
+    throw err;
+  }
+};
+
+// src/server/aws/ddb/literals.ts
+var lsi = { name: "lsi", sk: "lsi" };
+var lsi2 = { name: "lsi2", sk: "lsi2" };
+var lsiUsername = {
+  name: "username-lsi",
+  sk: "username"
+};
+var lsiNormalized = {
+  /** use in index_name */
+  name: "normalized-lsi",
+  sk: "normalized"
+};
+var lsiPhash = {
+  /** use in index_name */
+  name: "phash-lsi",
+  sk: "phash"
+};
+
+export { ddb_exports as DDB, dict_exports as Dict, file_exports as File, flow_exports as Flow, int_exports as Int, list_exports as List, log_exports as Log, money_exports as Money, random_exports as Random, str_exports as Str, time_exports as Time };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qstd",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "Standard Block component and utilities library with Panda CSS",
   "author": "malin1",
   "license": "MIT",
@@ -47,6 +47,8 @@
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
+    "@aws-sdk/client-dynamodb": "latest",
+    "@aws-sdk/lib-dynamodb": "latest",
     "@floating-ui/react": "^0.27.12",
     "@fortawesome/fontawesome-svg-core": "^7.0.0",
     "@fortawesome/free-brands-svg-icons": "^7.0.0",