dynamodb-expression-builder 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -154,6 +154,24 @@ const FILTER_OPERATORS = [
 			"L"
 		]
 	},
+	{
+		value: "not_contains",
+		label: "Not Contains",
+		symbol: "∌",
+		wireForm: "NOT_CONTAINS",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: [
+			"S",
+			"B",
+			"SS",
+			"NS",
+			"BS",
+			"L"
+		]
+	},
 	{
 		value: "begins_with",
 		label: "Begins With",
@@ -370,6 +388,9 @@ function buildOne(row, index, prefix, names, typedValues) {
 		case "CONTAINS":
 			typedValues[valueRef] = makeTypedValue(elementType(row.type), row.value);
 			return `contains(${nameRef}, ${valueRef})`;
+		case "NOT_CONTAINS":
+			typedValues[valueRef] = makeTypedValue(elementType(row.type), row.value);
+			return `NOT contains(${nameRef}, ${valueRef})`;
 		case "BEGINS_WITH":
 			typedValues[valueRef] = single$1(row);
 			return `begins_with(${nameRef}, ${valueRef})`;
@@ -726,7 +747,7 @@ function hasBinaryValue(request) {
 //#endregion
 //#region src/emit/sdk-v3.ts
 /** Operation → the `@aws-sdk/client-dynamodb` command class name. */
-const COMMAND_BY_OP = {
+const COMMAND_BY_OP$1 = {
 	GetItem: "GetItemCommand",
 	Query: "QueryCommand",
 	Scan: "ScanCommand",
@@ -784,11 +805,11 @@ function jsLiteral(value, indent) {
 }
 /** Emit the `new <Op>Command({...})` source snippet for a canonical request. */
 function emitSdkV3(request) {
-	return `new ${COMMAND_BY_OP[request.operation]}(${jsLiteral(buildSdkV3Params(request), 0)})`;
+	return `new ${COMMAND_BY_OP$1[request.operation]}(${jsLiteral(buildSdkV3Params(request), 0)})`;
 }
 /** The `@aws-sdk/client-dynamodb` command class name for an operation. */
 function sdkV3CommandName(operation) {
-	return COMMAND_BY_OP[operation];
+	return COMMAND_BY_OP$1[operation];
 }
 /**
 * Render an arbitrary params value as the same pretty-printed JS literal
@@ -967,6 +988,7 @@ function predicate(row) {
 		case "BETWEEN": return `${id} BETWEEN ${literal(makeTypedValue(row.type, row.value))} AND ${literal(makeTypedValue(row.type, row.value2 ?? ""))}`;
 		case "BEGINS_WITH": return `begins_with(${id}, ${literal(single(row))})`;
 		case "CONTAINS": return `contains(${id}, ${literal(makeTypedValue(elementType(row.type), row.value))})`;
+		case "NOT_CONTAINS": return `NOT contains(${id}, ${literal(makeTypedValue(elementType(row.type), row.value))})`;
 		case "IN": return `${id} IN (${(row.values ?? (row.value ? [row.value] : [])).map((m) => literal(makeTypedValue(row.type, m))).join(", ")})`;
 		case "EXISTS": return `${id} IS NOT MISSING`;
 		case "NOT_EXISTS": return `${id} IS MISSING`;
@@ -1095,7 +1117,7 @@ const REQUEST_CLASS_BY_OP$1 = {
 	Delete: "DeleteItemRequest"
 };
 /** Operation → the `DynamoDbClient` method. */
-const CLIENT_METHOD_BY_OP$2 = {
+const CLIENT_METHOD_BY_OP$6 = {
 	GetItem: "getItem",
 	Query: "query",
 	Scan: "scan",
@@ -1109,7 +1131,7 @@ function javaRequestClassName(operation) {
 }
 /** The `DynamoDbClient` method name for an operation (`query`, …). */
 function javaClientMethodName(operation) {
-	return CLIENT_METHOD_BY_OP$2[operation];
+	return CLIENT_METHOD_BY_OP$6[operation];
 }
 /** Java string literal — `JSON.stringify` escapes are all valid Java escapes. */
 function javaString(value) {
@@ -1188,7 +1210,7 @@ const INPUT_TYPE_BY_OP = {
 	Delete: "DeleteItemInput"
 };
 /** Operation → the `dynamodb.Client` method. */
-const CLIENT_METHOD_BY_OP$1 = {
+const CLIENT_METHOD_BY_OP$5 = {
 	GetItem: "GetItem",
 	Query: "Query",
 	Scan: "Scan",
@@ -1202,7 +1224,7 @@ function goInputTypeName(operation) {
 }
 /** The `dynamodb.Client` method name for an operation. */
 function goClientMethodName(operation) {
-	return CLIENT_METHOD_BY_OP$1[operation];
+	return CLIENT_METHOD_BY_OP$5[operation];
 }
 /** Go string literal — `JSON.stringify` escapes are all valid Go escapes. */
 function goString(value) {
@@ -1292,7 +1314,7 @@ const REQUEST_CLASS_BY_OP = {
 	Delete: "DeleteItemRequest"
 };
 /** Operation → the async `AmazonDynamoDBClient` method. */
-const CLIENT_METHOD_BY_OP = {
+const CLIENT_METHOD_BY_OP$4 = {
 	GetItem: "GetItemAsync",
 	Query: "QueryAsync",
 	Scan: "ScanAsync",
@@ -1306,7 +1328,7 @@ function dotnetRequestClassName(operation) {
 }
 /** The async client method name for an operation (`QueryAsync`, …). */
 function dotnetClientMethodName(operation) {
-	return CLIENT_METHOD_BY_OP[operation];
+	return CLIENT_METHOD_BY_OP$4[operation];
 }
 /** C# string literal — `JSON.stringify` escapes are all valid C# escapes. */
 function csString(value) {
@@ -1373,6 +1395,102 @@ function emitDotnet(request) {
 	return renderCsRequest(request, "");
 }
 
+//#endregion
+//#region src/emit/rust.ts
+/** Operation → the `aws_sdk_dynamodb::Client` fluent method. */
+const CLIENT_METHOD_BY_OP$3 = {
+	GetItem: "get_item",
+	Query: "query",
+	Scan: "scan",
+	Update: "update_item",
+	Put: "put_item",
+	Delete: "delete_item"
+};
+/** The `Client` method name (snake_case) for an operation. */
+function rustClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP$3[operation];
+}
+/** Rust string literal — JSON escapes with the three Rust-incompatible ones fixed. */
+function rustString(value) {
+	return JSON.stringify(value).replace(/\\b/g, "\\u{0008}").replace(/\\f/g, "\\u{000c}").replace(/\\u([0-9a-fA-F]{4})/g, "\\u{$1}");
+}
+/** `"…".to_string()` — the owned String the AttributeValue constructors take. */
+function rustOwned(value) {
+	return `${rustString(value)}.to_string()`;
+}
+/** Decode canonical base64 into a `Blob::new(vec![0x…])` (fail-loud on bad input). */
+function rustBlob(base64) {
+	let raw;
+	try {
+		raw = atob(base64);
+	} catch {
+		throw new Error(`invalid base64 in a binary (B/BS) value: ${base64}`);
+	}
+	return `Blob::new(vec![${Array.from(raw, (c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(", ")}])`;
+}
+/** Render one wire AttributeValue as an `AttributeValue::…` constructor. */
+function renderRustAv(av) {
+	if ("S" in av) return `AttributeValue::S(${rustOwned(av.S)})`;
+	if ("N" in av) return `AttributeValue::N(${rustOwned(av.N)})`;
+	if ("B" in av) return `AttributeValue::B(${rustBlob(av.B)})`;
+	if ("BOOL" in av) return `AttributeValue::Bool(${av.BOOL})`;
+	if ("SS" in av) return `AttributeValue::Ss(vec![${av.SS.map(rustOwned).join(", ")}])`;
+	if ("NS" in av) return `AttributeValue::Ns(vec![${av.NS.map(rustOwned).join(", ")}])`;
+	if ("BS" in av) return `AttributeValue::Bs(vec![${av.BS.map(rustBlob).join(", ")}])`;
+	return "AttributeValue::Null(true)";
+}
+/** One `.method(key, av)` line per entry of a typed map. */
+function avEntryLines(method, map, indent) {
+	return Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${indent}.${method}(${rustString(name)}, ${renderRustAv(av)})`);
+}
+/**
+* Render the fluent builder chain for a request — every line at `indent`,
+* starting with `.{op}()` and ending BEFORE `.send()` so callers own the
+* terminal (the bare emitter awaits inline; the program emitter may hand the
+* chain to `into_paginator()` instead). Exported for the program emitter.
+*/
+function renderRustBuilder(request, indent) {
+	const lines = [`${indent}.${CLIENT_METHOD_BY_OP$3[request.operation]}()`];
+	lines.push(`${indent}.table_name(${rustString(request.tableName)})`);
+	if (request.indexName) lines.push(`${indent}.index_name(${rustString(request.indexName)})`);
+	if (request.key) lines.push(...avEntryLines("key", request.key, indent));
+	if (request.item) lines.push(...avEntryLines("item", request.item, indent));
+	if (request.keyConditionExpression) lines.push(`${indent}.key_condition_expression(${rustString(request.keyConditionExpression)})`);
+	if (request.updateExpression) lines.push(`${indent}.update_expression(${rustString(request.updateExpression)})`);
+	if (request.conditionExpression) lines.push(`${indent}.condition_expression(${rustString(request.conditionExpression)})`);
+	if (request.filterExpression) lines.push(`${indent}.filter_expression(${rustString(request.filterExpression)})`);
+	if (request.projectionExpression) lines.push(`${indent}.projection_expression(${rustString(request.projectionExpression)})`);
+	if (request.names) lines.push(...Object.entries(request.names).map(([alias, name]) => `${indent}.expression_attribute_names(${rustString(alias)}, ${rustString(name)})`));
+	if (request.typedValues) lines.push(...avEntryLines("expression_attribute_values", request.typedValues, indent));
+	if (request.limit !== void 0) lines.push(`${indent}.limit(${request.limit})`);
+	if (request.consistentRead) lines.push(`${indent}.consistent_read(true)`);
+	if (request.scanIndexForward === false) lines.push(`${indent}.scan_index_forward(false)`);
+	if (request.exclusiveStartKey) lines.push(...avEntryLines("exclusive_start_key", request.exclusiveStartKey, indent));
+	return lines;
+}
+/** Does this request build any `AttributeValue`? Drives the program emitter's imports. */
+function rustUsesAttributeValue(request) {
+	return request.key !== void 0 || request.item !== void 0 || request.typedValues !== void 0 || request.exclusiveStartKey !== void 0;
+}
+/** Does this request build any binary Blob? Drives the `primitives::Blob` import. */
+function rustUsesBlob(request) {
+	return [
+		request.key,
+		request.item,
+		request.typedValues,
+		request.exclusiveStartKey
+	].some((map) => map && Object.values(typedMapToAvMap(map)).some((av) => "B" in av || "BS" in av));
+}
+/** Emit the bare fluent call for a canonical request (awaited, `?`-propagated). */
+function emitRust(request) {
+	return [
+		"let response = client",
+		...renderRustBuilder(request, "    "),
+		"    .send()",
+		"    .await?;"
+	].join("\n");
+}
+
 //#endregion
 //#region src/emit/ddbtoolbox.ts
 /** Key attr DynamoDB type (S/N/B) → the Table `type` string dynamodb-toolbox wants. */
@@ -1438,6 +1556,7 @@ function renderCondition(f) {
 	if (f.operator === "exists") return `{ attr: ${attr}, exists: true }`;
 	if (f.operator === "not_exists") return `{ attr: ${attr}, exists: false }`;
 	if (f.operator === "contains") return `{ attr: ${attr}, contains: ${val()} }`;
+	if (f.operator === "not_contains") return `{ not: { attr: ${attr}, contains: ${val()} } }`;
 	if (f.operator === "begins_with") return `{ attr: ${attr}, beginsWith: ${val()} }`;
 	if (f.operator === "between") return `{ attr: ${attr}, between: [${renderNativeValue(scalar(f.type, f.value))}, ${renderNativeValue(scalar(f.type, f.value2 ?? ""))}] }`;
 	if (f.operator === "in") return `{ attr: ${attr}, in: [${(f.values ?? []).map((v) => renderNativeValue(scalar(f.type, v))).join(", ")}] }`;
@@ -1583,6 +1702,292 @@ function emitDdbToolboxProgram(request, paginate) {
 	].filter((l) => l !== null).join("\n");
 }
 
+//#endregion
+//#region src/emit/docclient.ts
+/** Operation → the `@aws-sdk/lib-dynamodb` command class. */
+const COMMAND_BY_OP = {
+	GetItem: "GetCommand",
+	Query: "QueryCommand",
+	Scan: "ScanCommand",
+	Update: "UpdateCommand",
+	Put: "PutCommand",
+	Delete: "DeleteCommand"
+};
+/** The lib-dynamodb command class name for an operation. */
+function docClientCommandName(operation) {
+	return COMMAND_BY_OP[operation];
+}
+/** Render a typed map as a native-value object literal, one entry per line. */
+function renderNativeMap(map, indent) {
+	const inner = `${indent}  `;
+	return `{\n${Object.entries(map).map(([name, tv]) => `${inner}${JSON.stringify(name)}: ${renderNativeValue(tv)},`).join("\n")}\n${indent}}`;
+}
+/** Render the plain string map (`ExpressionAttributeNames`). */
+function renderNameMap$3(map, indent) {
+	const inner = `${indent}  `;
+	return `{\n${Object.entries(map).map(([alias, name]) => `${inner}${JSON.stringify(alias)}: ${JSON.stringify(name)},`).join("\n")}\n${indent}}`;
+}
+/**
+* Render the command's params object literal, one field per line at
+* `indent + 2`. Exported for the program emitter.
+*/
+function renderDocClientParams(request, indent) {
+	const pad = `${indent}  `;
+	const fields = [`TableName: ${JSON.stringify(request.tableName)},`];
+	if (request.indexName) fields.push(`IndexName: ${JSON.stringify(request.indexName)},`);
+	if (request.key) fields.push(`Key: ${renderNativeMap(request.key, pad)},`);
+	if (request.item) fields.push(`Item: ${renderNativeMap(request.item, pad)},`);
+	if (request.keyConditionExpression) fields.push(`KeyConditionExpression: ${JSON.stringify(request.keyConditionExpression)},`);
+	if (request.updateExpression) fields.push(`UpdateExpression: ${JSON.stringify(request.updateExpression)},`);
+	if (request.conditionExpression) fields.push(`ConditionExpression: ${JSON.stringify(request.conditionExpression)},`);
+	if (request.filterExpression) fields.push(`FilterExpression: ${JSON.stringify(request.filterExpression)},`);
+	if (request.projectionExpression) fields.push(`ProjectionExpression: ${JSON.stringify(request.projectionExpression)},`);
+	if (request.names) fields.push(`ExpressionAttributeNames: ${renderNameMap$3(request.names, pad)},`);
+	if (request.typedValues) fields.push(`ExpressionAttributeValues: ${renderNativeMap(request.typedValues, pad)},`);
+	if (request.limit !== void 0) fields.push(`Limit: ${request.limit},`);
+	if (request.consistentRead) fields.push("ConsistentRead: true,");
+	if (request.scanIndexForward === false) fields.push("ScanIndexForward: false,");
+	if (request.exclusiveStartKey) fields.push(`ExclusiveStartKey: ${renderNativeMap(request.exclusiveStartKey, pad)},`);
+	return [
+		"{",
+		...fields.map((f) => `${pad}${f}`),
+		`${indent}}`
+	].join("\n");
+}
+/** Emit the bare `new XCommand({…})` snippet with native values. */
+function emitDocClient(request) {
+	return `new ${COMMAND_BY_OP[request.operation]}(${renderDocClientParams(request, "")})`;
+}
+
+//#endregion
+//#region src/emit/kotlin.ts
+/** Operation → the `DynamoDbClient` suspend function. */
+const CLIENT_METHOD_BY_OP$2 = {
+	GetItem: "getItem",
+	Query: "query",
+	Scan: "scan",
+	Update: "updateItem",
+	Put: "putItem",
+	Delete: "deleteItem"
+};
+/** The client method name (camelCase) for an operation. */
+function kotlinClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP$2[operation];
+}
+/** Kotlin string literal — JSON escapes are valid Kotlin escapes, plus `$` must
+*  be escaped (string templates). */
+function ktString(value) {
+	return JSON.stringify(value).replace(/\$/g, "\\$");
+}
+/** Decode canonical base64 into a `byteArrayOf(0x…)` literal (fail-loud). */
+function ktBytes(base64) {
+	let raw;
+	try {
+		raw = atob(base64);
+	} catch {
+		throw new Error(`invalid base64 in a binary (B/BS) value: ${base64}`);
+	}
+	return `byteArrayOf(${Array.from(raw, (c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(", ")})`;
+}
+/** Render one wire AttributeValue as an `AttributeValue.…` constructor. */
+function renderKotlinAv(av) {
+	if ("S" in av) return `AttributeValue.S(${ktString(av.S)})`;
+	if ("N" in av) return `AttributeValue.N(${ktString(av.N)})`;
+	if ("B" in av) return `AttributeValue.B(${ktBytes(av.B)})`;
+	if ("BOOL" in av) return `AttributeValue.Bool(${av.BOOL})`;
+	if ("SS" in av) return `AttributeValue.Ss(listOf(${av.SS.map(ktString).join(", ")}))`;
+	if ("NS" in av) return `AttributeValue.Ns(listOf(${av.NS.map(ktString).join(", ")}))`;
+	if ("BS" in av) return `AttributeValue.Bs(listOf(${av.BS.map(ktBytes).join(", ")}))`;
+	return "AttributeValue.Null(true)";
+}
+/** Render a typed map as `mapOf("k" to AttributeValue.…)`, one entry per line. */
+function renderAvMap$1(map, indent) {
+	const inner = `${indent}    `;
+	return `mapOf(\n${Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${inner}${ktString(name)} to ${renderKotlinAv(av)},`).join("\n")}\n${indent})`;
+}
+/** Render the plain string map (`expressionAttributeNames`). */
+function renderNameMap$2(map, indent) {
+	const inner = `${indent}    `;
+	return `mapOf(\n${Object.entries(map).map(([alias, name]) => `${inner}${ktString(alias)} to ${ktString(name)},`).join("\n")}\n${indent})`;
+}
+/**
+* Render the builder-lambda body — one property assignment per line at
+* `indent`. Exported for the program emitter, which wraps the same body in
+* either the plain suspend call or the `Paginated` flow variant.
+*/
+function renderKotlinBuilder(request, indent) {
+	const lines = [`${indent}tableName = ${ktString(request.tableName)}`];
+	if (request.indexName) lines.push(`${indent}indexName = ${ktString(request.indexName)}`);
+	if (request.key) lines.push(`${indent}key = ${renderAvMap$1(request.key, indent)}`);
+	if (request.item) lines.push(`${indent}item = ${renderAvMap$1(request.item, indent)}`);
+	if (request.keyConditionExpression) lines.push(`${indent}keyConditionExpression = ${ktString(request.keyConditionExpression)}`);
+	if (request.updateExpression) lines.push(`${indent}updateExpression = ${ktString(request.updateExpression)}`);
+	if (request.conditionExpression) lines.push(`${indent}conditionExpression = ${ktString(request.conditionExpression)}`);
+	if (request.filterExpression) lines.push(`${indent}filterExpression = ${ktString(request.filterExpression)}`);
+	if (request.projectionExpression) lines.push(`${indent}projectionExpression = ${ktString(request.projectionExpression)}`);
+	if (request.names) lines.push(`${indent}expressionAttributeNames = ${renderNameMap$2(request.names, indent)}`);
+	if (request.typedValues) lines.push(`${indent}expressionAttributeValues = ${renderAvMap$1(request.typedValues, indent)}`);
+	if (request.limit !== void 0) lines.push(`${indent}limit = ${request.limit}`);
+	if (request.consistentRead) lines.push(`${indent}consistentRead = true`);
+	if (request.scanIndexForward === false) lines.push(`${indent}scanIndexForward = false`);
+	if (request.exclusiveStartKey) lines.push(`${indent}exclusiveStartKey = ${renderAvMap$1(request.exclusiveStartKey, indent)}`);
+	return lines;
+}
+/** Emit the bare `val response = client.…{ … }` call for a canonical request. */
+function emitKotlin(request) {
+	return [
+		`val response = client.${CLIENT_METHOD_BY_OP$2[request.operation]} {`,
+		...renderKotlinBuilder(request, "    "),
+		"}"
+	].join("\n");
+}
+
+//#endregion
+//#region src/emit/php.ts
+/** Operation → the `DynamoDbClient` method. */
+const CLIENT_METHOD_BY_OP$1 = {
+	GetItem: "getItem",
+	Query: "query",
+	Scan: "scan",
+	Update: "updateItem",
+	Put: "putItem",
+	Delete: "deleteItem"
+};
+/** The client method name (camelCase) for an operation. */
+function phpClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP$1[operation];
+}
+/** PHP single-quoted string — only `\` and `'` need escaping. */
+function phpString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/** Render one wire AttributeValue as a nested `['TAG' => …]` literal. */
+function renderPhpAv(av) {
+	if ("S" in av) return `['S' => ${phpString(av.S)}]`;
+	if ("N" in av) return `['N' => ${phpString(av.N)}]`;
+	if ("B" in av) return `['B' => base64_decode(${phpString(av.B)})]`;
+	if ("BOOL" in av) return `['BOOL' => ${av.BOOL}]`;
+	if ("SS" in av) return `['SS' => [${av.SS.map(phpString).join(", ")}]]`;
+	if ("NS" in av) return `['NS' => [${av.NS.map(phpString).join(", ")}]]`;
+	if ("BS" in av) return `['BS' => [${av.BS.map((b) => `base64_decode(${phpString(b)})`).join(", ")}]]`;
+	return "['NULL' => true]";
+}
+/** Render a typed map as a PHP array of AV literals, one entry per line. */
+function renderAvMap(map, indent) {
+	const inner = `${indent}    `;
+	return `[\n${Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${inner}${phpString(name)} => ${renderPhpAv(av)},`).join("\n")}\n${indent}]`;
+}
+/** Render the plain string map (`ExpressionAttributeNames`). */
+function renderNameMap$1(map, indent) {
+	const inner = `${indent}    `;
+	return `[\n${Object.entries(map).map(([alias, name]) => `${inner}${phpString(alias)} => ${phpString(name)},`).join("\n")}\n${indent}]`;
+}
+/**
+* Render the request array literal, one field per line at `indent + 4`.
+* Exported for the program emitter.
+*/
+function renderPhpParams(request, indent) {
+	const pad = `${indent}    `;
+	const fields = [`'TableName' => ${phpString(request.tableName)},`];
+	if (request.indexName) fields.push(`'IndexName' => ${phpString(request.indexName)},`);
+	if (request.key) fields.push(`'Key' => ${renderAvMap(request.key, pad)},`);
+	if (request.item) fields.push(`'Item' => ${renderAvMap(request.item, pad)},`);
+	if (request.keyConditionExpression) fields.push(`'KeyConditionExpression' => ${phpString(request.keyConditionExpression)},`);
+	if (request.updateExpression) fields.push(`'UpdateExpression' => ${phpString(request.updateExpression)},`);
+	if (request.conditionExpression) fields.push(`'ConditionExpression' => ${phpString(request.conditionExpression)},`);
+	if (request.filterExpression) fields.push(`'FilterExpression' => ${phpString(request.filterExpression)},`);
+	if (request.projectionExpression) fields.push(`'ProjectionExpression' => ${phpString(request.projectionExpression)},`);
+	if (request.names) fields.push(`'ExpressionAttributeNames' => ${renderNameMap$1(request.names, pad)},`);
+	if (request.typedValues) fields.push(`'ExpressionAttributeValues' => ${renderAvMap(request.typedValues, pad)},`);
+	if (request.limit !== void 0) fields.push(`'Limit' => ${request.limit},`);
+	if (request.consistentRead) fields.push("'ConsistentRead' => true,");
+	if (request.scanIndexForward === false) fields.push("'ScanIndexForward' => false,");
+	if (request.exclusiveStartKey) fields.push(`'ExclusiveStartKey' => ${renderAvMap(request.exclusiveStartKey, pad)},`);
+	return [
+		"[",
+		...fields.map((f) => `${pad}${f}`),
+		`${indent}]`
+	].join("\n");
+}
+/** Emit the bare `$response = $client->…([…]);` call for a canonical request. */
+function emitPhp(request) {
+	return `$response = $client->${CLIENT_METHOD_BY_OP$1[request.operation]}(${renderPhpParams(request, "")});`;
+}
+
+//#endregion
+//#region src/emit/ruby.ts
+/** Operation → the `Aws::DynamoDB::Client` method (snake_case). */
+const CLIENT_METHOD_BY_OP = {
+	GetItem: "get_item",
+	Query: "query",
+	Scan: "scan",
+	Update: "update_item",
+	Put: "put_item",
+	Delete: "delete_item"
+};
+/** The client method name (snake_case) for an operation. */
+function rubyClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP[operation];
+}
+/** Ruby single-quoted string — only `\` and `'` need escaping. */
+function rubyString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/** Render one typed value as the native Ruby literal the SDK marshals. */
+function renderRubyValue(tv) {
+	switch (tv.type) {
+		case "S": return rubyString(tv.value);
+		case "N": return tv.value;
+		case "B": return `Base64.decode64(${rubyString(tv.value)})`;
+		case "BOOL": return tv.value === "true" ? "true" : "false";
+		case "NULL": return "nil";
+		case "SS": return `Set.new([${(tv.values ?? []).map(rubyString).join(", ")}])`;
+		case "NS": return `Set.new([${(tv.values ?? []).join(", ")}])`;
+		case "BS": return `Set.new([${(tv.values ?? []).map((b) => `Base64.decode64(${rubyString(b)})`).join(", ")}])`;
+	}
+}
+/** Render a typed map as a Ruby hash of native values, one entry per line. */
+function renderValueMap(map, indent) {
+	const inner = `${indent}  `;
+	return `{\n${Object.entries(map).map(([name, tv]) => `${inner}${rubyString(name)} => ${renderRubyValue(tv)},`).join("\n")}\n${indent}}`;
+}
+/** Render the plain string map (`expression_attribute_names`). */
+function renderNameMap(map, indent) {
+	const inner = `${indent}  `;
+	return `{\n${Object.entries(map).map(([alias, name]) => `${inner}${rubyString(alias)} => ${rubyString(name)},`).join("\n")}\n${indent}}`;
+}
+/**
+* Render the request keyword-argument hash, one field per line at `indent + 2`.
+* Exported for the program emitter.
+*/
+function renderRubyParams(request, indent) {
+	const pad = `${indent}  `;
+	const fields = [`table_name: ${rubyString(request.tableName)},`];
+	if (request.indexName) fields.push(`index_name: ${rubyString(request.indexName)},`);
+	if (request.key) fields.push(`key: ${renderValueMap(request.key, pad)},`);
+	if (request.item) fields.push(`item: ${renderValueMap(request.item, pad)},`);
+	if (request.keyConditionExpression) fields.push(`key_condition_expression: ${rubyString(request.keyConditionExpression)},`);
+	if (request.updateExpression) fields.push(`update_expression: ${rubyString(request.updateExpression)},`);
+	if (request.conditionExpression) fields.push(`condition_expression: ${rubyString(request.conditionExpression)},`);
+	if (request.filterExpression) fields.push(`filter_expression: ${rubyString(request.filterExpression)},`);
+	if (request.projectionExpression) fields.push(`projection_expression: ${rubyString(request.projectionExpression)},`);
+	if (request.names) fields.push(`expression_attribute_names: ${renderNameMap(request.names, pad)},`);
+	if (request.typedValues) fields.push(`expression_attribute_values: ${renderValueMap(request.typedValues, pad)},`);
+	if (request.limit !== void 0) fields.push(`limit: ${request.limit},`);
+	if (request.consistentRead) fields.push("consistent_read: true,");
+	if (request.scanIndexForward === false) fields.push("scan_index_forward: false,");
+	if (request.exclusiveStartKey) fields.push(`exclusive_start_key: ${renderValueMap(request.exclusiveStartKey, pad)},`);
+	return [
+		"{",
+		...fields.map((f) => `${pad}${f}`),
+		`${indent}}`
+	].join("\n");
+}
+/** Emit the bare `response = client.…(…)` call for a canonical request. */
+function emitRuby(request) {
+	return `response = client.${CLIENT_METHOD_BY_OP[request.operation]}(${renderRubyParams(request, "")})`;
+}
+
 //#endregion
 //#region src/program.ts
 /**
@@ -1627,6 +2032,26 @@ function emitQueryProgram(config, format) {
 			ok: true,
 			code: emitDotnetProgram(request, config.paginate === true)
 		};
+		case "rust": return {
+			ok: true,
+			code: emitRustProgram(request, config.paginate === true)
+		};
+		case "docclient": return {
+			ok: true,
+			code: emitDocClientProgram(request, config.paginate === true)
+		};
+		case "kotlin": return {
+			ok: true,
+			code: emitKotlinProgram(request, config.paginate === true)
+		};
+		case "php": return {
+			ok: true,
+			code: emitPhpProgram(request, config.paginate === true)
+		};
+		case "ruby": return {
+			ok: true,
+			code: emitRubyProgram(request, config.paginate === true)
+		};
 		case "ddbtoolbox": return {
 			ok: true,
 			code: emitDdbToolboxProgram(request, config.paginate === true)
@@ -1824,6 +2249,173 @@ function emitGoProgram(request, paginate) {
 		"}"
 	].join("\n");
 }
+function emitRustProgram(request, paginate) {
+	const usesAv = rustUsesAttributeValue(request);
+	const usesBlob = rustUsesBlob(request);
+	const header = [
+		...[
+			"// Cargo.toml: aws-config, aws-sdk-dynamodb, tokio (features = [\"full\"])",
+			"use aws_sdk_dynamodb::Client;",
+			...usesAv ? ["use aws_sdk_dynamodb::types::AttributeValue;"] : [],
+			...usesBlob ? ["use aws_sdk_dynamodb::primitives::Blob;"] : []
+		],
+		"",
+		"#[tokio::main]",
+		"async fn main() -> Result<(), aws_sdk_dynamodb::Error> {",
+		"    let config = aws_config::load_from_env().await;",
+		"    let client = Client::new(&config);",
+		""
+	];
+	const builder = renderRustBuilder(request, "        ");
+	if (!paginate) return [
+		...header,
+		"    let response = client",
+		...builder,
+		"        .send()",
+		"        .await?;",
+		"    println!(\"{:?}\", response.items());",
+		"",
+		"    Ok(())",
+		"}"
+	].join("\n");
+	return [
+		...header,
+		"    let mut items = client",
+		...builder,
+		"        .into_paginator()",
+		"        .items()",
+		"        .send();",
+		"",
+		"    while let Some(item) = items.next().await {",
+		"        println!(\"{:?}\", item?);",
+		"    }",
+		"",
+		"    Ok(())",
+		"}"
+	].join("\n");
+}
+function emitDocClientProgram(request, paginate) {
+	const command = docClientCommandName(request.operation);
+	renderDocClientParams(request, "");
+	if (!paginate) return [
+		"import { DynamoDBClient } from \"@aws-sdk/client-dynamodb\";",
+		`import { DynamoDBDocumentClient, ${command} } from "@aws-sdk/lib-dynamodb";`,
+		"",
+		"const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));",
+		"",
+		"const response = await client.send(",
+		`  new ${command}(${renderDocClientParams(request, "  ")})`,
+		");",
+		"",
+		"console.log(response.Items);"
+	].join("\n");
+	const paginator = request.operation === "Scan" ? "paginateScan" : "paginateQuery";
+	return [
+		"import { DynamoDBClient } from \"@aws-sdk/client-dynamodb\";",
+		`import { DynamoDBDocumentClient, ${paginator} } from "@aws-sdk/lib-dynamodb";`,
+		"",
+		"const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));",
+		"",
+		`const paginator = ${paginator}(`,
+		"  { client },",
+		`  ${renderDocClientParams(request, "  ")}`,
+		");",
+		"",
+		"for await (const page of paginator) {",
+		"  console.log(page.Items);",
+		"}"
+	].join("\n");
+}
+function emitKotlinProgram(request, paginate) {
+	const method = kotlinClientMethodName(request.operation);
+	const header = [
+		"import aws.sdk.kotlin.services.dynamodb.DynamoDbClient",
+		"import aws.sdk.kotlin.services.dynamodb.model.AttributeValue",
+		...paginate ? [
+			`import aws.sdk.kotlin.services.dynamodb.paginators.${method}Paginated`,
+			"import aws.sdk.kotlin.services.dynamodb.paginators.items",
+			"import kotlinx.coroutines.flow.collect"
+		] : [],
+		"",
+		"suspend fun main() {",
+		"    DynamoDbClient.fromEnvironment().use { client ->"
+	];
+	const body = renderKotlinBuilder(request, "            ");
+	if (!paginate) return [
+		...header,
+		`        val response = client.${method} {`,
+		...body,
+		"        }",
+		"        println(response.items)",
+		"    }",
+		"}"
+	].join("\n");
+	return [
+		...header,
+		`        client.${method}Paginated {`,
+		...body,
+		"        }",
+		"            .items()",
+		"            .collect { item -> println(item) }",
+		"    }",
+		"}"
+	].join("\n");
+}
+function emitPhpProgram(request, paginate) {
+	const method = phpClientMethodName(request.operation);
+	const header = [
+		"<?php",
+		"",
+		"require 'vendor/autoload.php';",
+		"",
+		"use Aws\\DynamoDb\\DynamoDbClient;",
+		"",
+		"$client = new DynamoDbClient(['region' => 'us-east-1', 'version' => 'latest']);",
+		""
+	];
+	if (!paginate) return [
+		...header,
+		`$response = $client->${method}(${renderPhpParams(request, "")});`,
+		"",
+		"print_r($response['Items']);"
+	].join("\n");
+	const operation = request.operation === "Scan" ? "Scan" : "Query";
+	return [
+		...header,
+		`$pages = $client->getPaginator('${operation}', ${renderPhpParams(request, "")});`,
+		"",
+		"foreach ($pages as $page) {",
+		"    print_r($page['Items']);",
+		"}"
+	].join("\n");
+}
+function emitRubyProgram(request, paginate) {
+	const method = rubyClientMethodName(request.operation);
+	const usesSets = /Set\.new\(/.test(renderRubyParams(request, ""));
+	const usesBase64 = /Base64\.decode64\(/.test(renderRubyParams(request, ""));
+	const header = [
+		"require 'aws-sdk-dynamodb'",
+		...usesSets ? ["require 'set'"] : [],
+		...usesBase64 ? ["require 'base64'"] : [],
+		"",
+		"client = Aws::DynamoDB::Client.new",
+		""
+	];
+	if (!paginate) return [
+		...header,
+		`response = client.${method}(${renderRubyParams(request, "")})`,
+		"",
+		"puts response.items"
+	].join("\n");
+	return [
+		...header,
+		`response = client.${method}(${renderRubyParams(request, "")})`,
+		"",
+		"response.each do |page|",
+		"  puts page.items",
+		"end"
+	].join("\n");
+}
 function emitDotnetProgram(request, paginate) {
 	const method = dotnetClientMethodName(request.operation);
 	const binary = hasBinaryValue(request);
@@ -1880,17 +2472,23 @@ exports.buildKeyMap = buildKeyMap;
 exports.buildRequest = buildRequest;
 exports.buildSdkV3Params = buildSdkV3Params;
 exports.buildUpdateExpression = buildUpdateExpression;
+exports.docClientCommandName = docClientCommandName;
 exports.dotnetClientMethodName = dotnetClientMethodName;
 exports.dotnetRequestClassName = dotnetRequestClassName;
 exports.elementType = elementType;
 exports.emitBoto3 = emitBoto3;
 exports.emitCli = emitCli;
 exports.emitDdbToolboxProgram = emitDdbToolboxProgram;
+exports.emitDocClient = emitDocClient;
 exports.emitDotnet = emitDotnet;
 exports.emitGo = emitGo;
 exports.emitJava = emitJava;
+exports.emitKotlin = emitKotlin;
 exports.emitPartiql = emitPartiql;
+exports.emitPhp = emitPhp;
 exports.emitQueryProgram = emitQueryProgram;
+exports.emitRuby = emitRuby;
+exports.emitRust = emitRust;
 exports.emitSdkV3 = emitSdkV3;
 exports.getCompatibleComparisonOperators = getCompatibleComparisonOperators;
 exports.getCompatibleFilterOperators = getCompatibleFilterOperators;
@@ -1900,9 +2498,17 @@ exports.hasBinaryValue = hasBinaryValue;
 exports.isSetType = isSetType;
 exports.javaClientMethodName = javaClientMethodName;
 exports.javaRequestClassName = javaRequestClassName;
+exports.kotlinClientMethodName = kotlinClientMethodName;
 exports.makeTypedValue = makeTypedValue;
+exports.phpClientMethodName = phpClientMethodName;
 exports.renderJsValue = renderJsValue;
+exports.renderKotlinAv = renderKotlinAv;
+exports.renderPhpAv = renderPhpAv;
 exports.renderPyValue = renderPyValue;
+exports.renderRubyValue = renderRubyValue;
+exports.renderRustAv = renderRustAv;
+exports.rubyClientMethodName = rubyClientMethodName;
+exports.rustClientMethodName = rustClientMethodName;
 exports.sdkV3CommandName = sdkV3CommandName;
 exports.typedMapToAvMap = typedMapToAvMap;
 exports.typedValueToAv = typedValueToAv;