appflare 0.2.36 → 0.2.38

package/cli/templates/handlers/generators/types/query-definitions/query-helper-functions.ts

@@ -4,11 +4,285 @@ export function generateQueryHelperFunctionsSection(): string {
 }
 
 function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
-	if (record[key] !== undefined) {
-		return record[key];
+	return record[key];
+}
+
+function getJsonColumnsMap(): Record<string, Record<string, { shape: unknown }>> {
+	const rawValue = (mergedSchema as Record<string, unknown>)[
+		"__appflareJsonColumns"
+	];
+	if (!isRecord(rawValue)) {
+		return {};
+	}
+	const map: Record<string, Record<string, { shape: unknown }>> = {};
+	for (const [tableName, tableValue] of Object.entries(rawValue)) {
+		if (isRecord(tableValue)) {
+			map[tableName] = tableValue as Record<string, { shape: unknown }>;
+		}
 	}
-	const prefixed = "$" + key;
-	return record[prefixed];
+	return map;
+}
+
+const jsonColumnsMap = getJsonColumnsMap();
+
+function getJsonColumnShape(
+	tableName: string | undefined,
+	fieldName: string,
+): { kind: string } | null {
+	if (!tableName) return null;
+	const tableCols = jsonColumnsMap[tableName];
+	if (!tableCols) return null;
+	const col = tableCols[fieldName];
+	if (!col || !isRecord(col.shape)) return null;
+	return col.shape as { kind: string };
+}
+
+function buildJsonFieldFilter(
+	fieldName: string,
+	field: unknown,
+	value: unknown,
+	tableName: string | undefined,
+): SQL | undefined {
+	const shape = getJsonColumnShape(tableName, fieldName);
+	if (!shape) return undefined;
+
+	if (shape.kind === "array") {
+		return buildJsonArrayFilter(fieldName, field, value);
+	}
+	if (shape.kind === "object") {
+		return buildJsonObjectFilter(fieldName, field, value);
+	}
+	return undefined;
+}
+
+function buildJsonArrayElementMatchCondition(
+	field: unknown,
+	matchValue: unknown,
+): SQL {
+	if (!isRecord(matchValue) || matchValue instanceof Date || Array.isArray(matchValue)) {
+		return sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE j.value = \${matchValue})\`;
+	}
+
+	const propConditions: SQL[] = [];
+	for (const [key, propValue] of Object.entries(matchValue)) {
+		const jsonPath = '$.' + key;
+		if (!isRecord(propValue) || propValue instanceof Date || Array.isArray(propValue)) {
+			propConditions.push(
+				sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) = \${propValue})\`,
+			);
+		} else {
+			const nestedConditions: SQL[] = [];
+			const eqVal = readOperatorValue(propValue, "eq");
+			if (eqVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) = \${eqVal})\`,
+				);
+			}
+			const neVal = readOperatorValue(propValue, "ne");
+			if (neVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) != \${neVal})\`,
+				);
+			}
+			const gtVal = readOperatorValue(propValue, "gt");
+			if (gtVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) > \${gtVal})\`,
+				);
+			}
+			const gteVal = readOperatorValue(propValue, "gte");
+			if (gteVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) >= \${gteVal})\`,
+				);
+			}
+			const ltVal = readOperatorValue(propValue, "lt");
+			if (ltVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) < \${ltVal})\`,
+				);
+			}
+			const lteVal = readOperatorValue(propValue, "lte");
+			if (lteVal !== undefined) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) <= \${lteVal})\`,
+				);
+			}
+			const inVal = readOperatorValue(propValue, "in");
+			if (Array.isArray(inVal) && inVal.length > 0) {
+				nestedConditions.push(
+					sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_extract(j.value, \${jsonPath}) IN (\${sql.join(inVal.map((v) => sql\`\${v}\`), sql\`, \`)})\`,
+				);
+			}
+			if (nestedConditions.length > 0) {
+				propConditions.push(
+					nestedConditions.length === 1
+						? nestedConditions[0]
+						: and(...nestedConditions),
+				);
+			}
+		}
+	}
+
+	if (propConditions.length === 0) {
+		return sql\`EXISTS (SELECT 1 FROM json_each(\${field as never}) j WHERE json_type(j.value) = 'object')\`;
+	}
+
+	if (propConditions.length === 1) {
+		return propConditions[0];
+	}
+
+	return and(...propConditions);
+}
+
+function buildJsonArrayFilter(
+	fieldName: string,
+	field: unknown,
+	value: unknown,
+): SQL | undefined {
+	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
+		return sql\`json_extract(\${field as never}, '$') = json(\${JSON.stringify(value)})\`;
+	}
+
+	const filters: SQL[] = [];
+
+	const includesValue = readOperatorValue(value, "includes");
+	if (Array.isArray(includesValue) && includesValue.length > 0) {
+		const conditions = includesValue.map((v) =>
+			buildJsonArrayElementMatchCondition(field, v),
+		);
+		filters.push(and(...conditions));
+	}
+
+	const includesAnyValue = readOperatorValue(value, "includesAny");
+	if (Array.isArray(includesAnyValue) && includesAnyValue.length > 0) {
+		const conditions = includesAnyValue.map((v) =>
+			buildJsonArrayElementMatchCondition(field, v),
+		);
+		filters.push(sql\`(\${sql.join(conditions, sql\` OR \`)})\`);
+	}
+
+	const lengthValue = readOperatorValue(value, "length");
+	if (lengthValue !== undefined) {
+		filters.push(sql\`json_array_length(\${field as never}) = \${lengthValue}\`);
+	}
+
+	const eqValue = readOperatorValue(value, "eq");
+	if (eqValue !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, '$') = json(\${JSON.stringify(eqValue)})\`);
+	}
+
+	const neValue = readOperatorValue(value, "ne");
+	if (neValue !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, '$') != json(\${JSON.stringify(neValue)})\`);
+	}
+
+	if (filters.length === 0) {
+		return undefined;
+	}
+	if (filters.length === 1) return filters[0];
+	return and(...filters);
+}
+
+function buildJsonObjectFilter(
+	fieldName: string,
+	field: unknown,
+	value: unknown,
+): SQL | undefined {
+	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
+		return sql\`json_extract(\${field as never}, '$') = json(\${JSON.stringify(value)})\`;
+	}
+
+	const filters: SQL[] = [];
+
+	for (const [key, opValue] of Object.entries(value)) {
+		if (key === "eq") {
+			filters.push(sql\`json_extract(\${field as never}, '$') = json(\${JSON.stringify(opValue)})\`);
+			continue;
+		}
+		if (key === "ne") {
+			filters.push(sql\`json_extract(\${field as never}, '$') != json(\${JSON.stringify(opValue)})\`);
+			continue;
+		}
+		if (key === "exists") {
+			filters.push(
+				opValue
+					? sql\`json_extract(\${field as never}, '$') IS NOT NULL\`
+					: sql\`json_extract(\${field as never}, '$') IS NULL\`,
+			);
+			continue;
+		}
+
+		const nestedFilters = buildJsonObjectPathFilter(field, key, opValue);
+		if (nestedFilters) {
+			filters.push(nestedFilters);
+		}
+	}
+
+	if (filters.length === 0) return undefined;
+	if (filters.length === 1) return filters[0];
+	return and(...filters);
+}
+
+function buildJsonObjectPathFilter(
+	field: unknown,
+	path: string,
+	opValue: unknown,
+): SQL | undefined {
+	const jsonPath = '$.' + path;
+	if (!isRecord(opValue) || opValue instanceof Date || Array.isArray(opValue)) {
+		return sql\`json_extract(\${field as never}, \${jsonPath}) = \${opValue}\`;
+	}
+
+	const filters: SQL[] = [];
+
+	const eqVal = readOperatorValue(opValue, "eq");
+	if (eqVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) = \${eqVal}\`);
+	}
+
+	const neVal = readOperatorValue(opValue, "ne");
+	if (neVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) != \${neVal}\`);
+	}
+
+	const gtVal = readOperatorValue(opValue, "gt");
+	if (gtVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) > \${gtVal}\`);
+	}
+
+	const gteVal = readOperatorValue(opValue, "gte");
+	if (gteVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) >= \${gteVal}\`);
+	}
+
+	const ltVal = readOperatorValue(opValue, "lt");
+	if (ltVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) < \${ltVal}\`);
+	}
+
+	const lteVal = readOperatorValue(opValue, "lte");
+	if (lteVal !== undefined) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) <= \${lteVal}\`);
+	}
+
+	const inVal = readOperatorValue(opValue, "in");
+	if (Array.isArray(inVal) && inVal.length > 0) {
+		filters.push(sql\`json_extract(\${field as never}, \${jsonPath}) IN (\${sql.join(inVal.map((v) => sql\`\${v}\`), sql\`, \`)})\`);
+	}
+
+	const existsVal = readOperatorValue(opValue, "exists");
+	if (typeof existsVal === "boolean") {
+		filters.push(
+			existsVal
+				? sql\`json_extract(\${field as never}, \${jsonPath}) IS NOT NULL\`
+				: sql\`json_extract(\${field as never}, \${jsonPath}) IS NULL\`,
+		);
+	}
+
+	if (filters.length === 0) return undefined;
+	if (filters.length === 1) return filters[0];
+	return and(...filters);
 }
 
 function normalizeGeoPoint(
@@ -90,17 +364,13 @@ function createGeoDistanceFilter(
 	)\`;
 
 	const minDistance =
-		operand.$minDistance ??
+		operand.minDistance ??
 		operand.gte ??
-		operand.$gte ??
-		operand.gt ??
-		operand.$gt;
+		operand.gt;
 	const maxDistance =
-		operand.$maxDistance ??
+		operand.maxDistance ??
 		operand.lte ??
-		operand.$lte ??
-		operand.lt ??
-		operand.$lt;
+		operand.lt;
 
 	const filters: SQL[] = [];
 	if (typeof minDistance === "number") {
@@ -126,7 +396,18 @@ function buildFieldFilter(
 	field: unknown,
 	value: unknown,
 	fields: Record<string, unknown>,
+	tableName?: string,
 ): SQL | undefined {
+	const jsonFilter = buildJsonFieldFilter(fieldName, field, value, tableName);
+	if (jsonFilter) return jsonFilter;
+
+	const isArrayColumn = isRecord(value) && !Array.isArray(value) && !(value instanceof Date) &&
+		("includes" in value || "includesAny" in value || "length" in value);
+	if (isArrayColumn) {
+		const arrayFilter = buildJsonArrayFilter(fieldName, field, value);
+		if (arrayFilter) return arrayFilter;
+	}
+
 	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
 		return eq(field as never, value as never);
 	}
@@ -237,9 +518,7 @@ function buildWhereFilterFromFields(
 
 	const topLevelGeoWithin = isRecord(where.geoWithin)
 		? (where.geoWithin as GeoWithinOperand)
-		: isRecord(where.$geoWithin)
-			? (where.$geoWithin as GeoWithinOperand)
-			: undefined;
+		: undefined;
 
 	if (topLevelGeoWithin) {
 		const geoFilter = createGeoDistanceFilter(topLevelGeoWithin, fields, tableName);
@@ -249,7 +528,7 @@ function buildWhereFilterFromFields(
 	}
 
 	for (const [fieldName, fieldValue] of Object.entries(where)) {
-		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
+		if (fieldName === "geoWithin") {
 			continue;
 		}
 
@@ -277,7 +556,7 @@ function buildWhereFilterFromFields(
 			continue;
 		}
 
-		const filter = buildFieldFilter(fieldName, field, fieldValue, fields);
+		const filter = buildFieldFilter(fieldName, field, fieldValue, fields, tableName);
 		if (filter) {
 			filters.push(filter);
 		}

package/cli/templates/handlers/index.ts

@@ -13,8 +13,9 @@ export function generateHandlersArtifacts(
 	schemaImportPath: string,
 	operations: DiscoveredHandlerOperation[],
 	defaultR2Binding?: string,
+	roles: string[] = [],
 ): GeneratedHandlerArtifact[] {
-	const handlersSource = generateHandlersSource(schemaImportPath);
+	const handlersSource = generateHandlersSource(schemaImportPath, roles);
 
 	const contextSource = generateContextSource(defaultR2Binding);
 

package/cli/templates/handlers/types.ts

@@ -4,12 +4,12 @@ import { generateTypesQueryRuntimeSection } from "./generators/types/query-runti
 import { generateTypesContextSection } from "./generators/types/context";
 import { generateTypesOperationsSection } from "./generators/types/operations";
 
-export function generateTypes(): string {
+export function generateTypes(roles: string[] = []): string {
 	return [
 		generateTypesCoreSection(),
 		generateTypesQueryDefinitionsSection(),
 		generateTypesQueryRuntimeSection(),
-		generateTypesContextSection(),
+		generateTypesContextSection(roles),
 		generateTypesOperationsSection(),
 	].join("\n\n");
 }