dataminion
commented
1 week ago So its wild that you just submitted this I was down the exact same rabbit hole last night.
It's not constructive to your problem but part of me started thinking about if I want lambdas internal to my project hitting the appsync surface. My personal preference for both security and cost would be to go straight to the underlying service I was going to make a comprehensive feature request then I changed my mind about it so I my end to end fake usecase is burning a hole in my pocket.
I think that from an Amplify perspective what I am follows is technically an antipattern but if you are encountering the problem in this ticket it is a solution that worked for us and does leverage the SCHEMA["Object"["Type"] pattern so that the intention of our design is present in the solution.
Imagine we have a Data Object that represents requests to do service on vehicles for different groups in the company.
This is a new feature for most of the company who will use our app but one division in a remote area had an existing system that involved paper requests. Another Technical team made a shim to solve the issue without conflict by using OCR on pictures of the requests and shipping us the outputs in an SQS queue.
The goal is to use the lambda to take the record and merge it into our other records. Beyond the example in this issue Using appSync as the surface doesn't make complete sense here while the record is new to us it isn't really new from a chain of custody perspective we want to preserve the original createdAt time for example without adding additional complexity to our other codebase.
This is very possible to do and is working for us right now on another use case but because of the modeling its alot of code for a relatively simple task. To me it all becomes a non issue if there was an extension of {Schema} that gives you not just a type but an object that could hold a record and have getter hooks to give you the object to you in the format of a different service like dynamo expects
import type { SQSHandler } from "aws-lambda";
import { Logger } from "@aws-lambda-powertools/logger";
import { DynamoDBClient, PutItemCommand, PutItemCommandInput } from "@aws-sdk/client-dynamodb";
import { marshall, marshallOptions } from "@aws-sdk/util-dynamodb";
import { env } from '$amplify/env/function-object-sync-source';
import { Schema } from "../../data/resource";
import { v4 as uuidv4 } from 'uuid';
type EmployeeRequest = Schema['EmployeeRequest']['type'];
const region = env.APP_REGION;
const dynamoTable = env.DYNAMODB_TABLE;
const logger = new Logger({
logLevel: "DEBUG",
serviceName: "object-sync-source-handler",
});
const dynamoDbClient = new DynamoDBClient({ logger,region });
export const handler: SQSHandler = async (event) => {
logger.debug(`Starting: Sync Process`);
const batchItemFailures = [];
for (const record of event.Records) {
try {
logger.debug(`Received message: ${record.body}`);
const message = JSON.parse(record.body as string);
const employeeRequest: EmployeeRequest = {
id: message.guid as string,
sourceId: message.id as string,
request: message.request_ocr as string,
vehicle: {id: message.vid as string, color: message.vehicle_color as string, type: message.vehicle_type as string},
organization: {id: message.org_id as number, name: message.org_name as string, type: message.org_type as number},
scannedAt: message.scanned_at,
createdAt: message.created_at,
updatedAt: message.created_at
}
await writeToDynamoDB(employeeRequest, dynamoTable);
logger.info(`EmployeeRequest: ${employeeRequest.sourceId} Has Been Created or Updated`);
} catch (error) {
logger.error(`Error processing record ${record.body}: ${error}`);
batchItemFailures.push({ itemIdentifier: record.messageId });
}
}
return {batchItemFailures}
};
async function writeToDynamoDB(employeeRequest: EmployeeRequest, dynamoTable: string) {
const uniqueId = uuidv4();
const options: marshallOptions = {
removeUndefinedValues: true,
convertClassInstanceToMap: true
};
try {
if (!employeeRequest.id) {
employeeRequest.id = uniqueId;
}
const putParams: PutItemCommandInput = {
TableName: dynamoTable,
Item: {
"id": { "S": employeeRequest.id },
"sourceId": { "S": employeeRequest.sourceId as string },
"__typename": { "S": "EmployeeRequest" },
"request": { "S": employeeRequest.request as string },
"vehicle": { "M": marshall(employeeRequest.vehicle, options) },
"organization": { "M": marshall(employeeRequest.organization, options) },
"scannedAt": { "S": employeeRequest.scannedAt as string },
"createdAt": { "S": employeeRequest.createdAt as string },
"updatedAt": { "S": employeeRequest.createdAt as string }
}
};
logger.debug(`Payload: ${JSON.stringify(putParams)}`);
const putItemCommand = new PutItemCommand(putParams);
await dynamoDbClient.send(putItemCommand);
logger.info(`Successfully wrote record to DynamoDB`);
} catch (error) {
logger.error(`Error writing to DynamoDB: ${error}`);
throw new Error(`Error writing to DynamoDB`);
}
}Hopefully this is useful to someone out there
ykethan
jpkraemer
Environment information
Describe the bug
I try to use a lambda function that accesses my GraphQL API. This is how my lambda function looks like:
(Handler abbreviated to conceal the application under development).
When I deploy this, I get an error "Cannot find package 'aws-amplify'" when running the lambda. I cannot for the life of me figure out how to get esbuild to bundle the dependency automatically. Any ideas on how to fix this?
Reproduction steps
see above