@aws-amplify/data-schema 0.13.13 → 0.13.14

package/lib-esm/src/Authorization.d.ts

@@ -1,4 +1,4 @@
-import type { UnionToIntersection, FunctionSchemaAccess } from '@aws-amplify/data-schema-types';
+import type { UnionToIntersection, DefineFunction } from '@aws-amplify/data-schema-types';
 declare const __data: unique symbol;
 /**
  * All possible providers.
@@ -53,7 +53,6 @@ export type SchemaAuthorization<AuthStrategy extends Strategy, AuthField extends
 export type ResourceAuthorization = {
     [__data]: ResourceAuthorizationData;
 };
-type DefineFunction = FunctionSchemaAccess['resourceProvider'];
 export type ResourceAuthorizationData = {
     strategy: 'resource';
     resource: DefineFunction;

package/lib-esm/src/CustomOperation.d.ts

@@ -43,6 +43,14 @@ export type CustomOperationParamShape = {
 export type CustomOperation<T extends CustomOperationParamShape, K extends keyof CustomOperation<T> = never, B extends CustomOperationBrand = CustomOperationBrand> = Omit<{
     arguments<Arguments extends CustomArguments>(args: Arguments): CustomOperation<SetTypeSubArg<T, 'arguments', Arguments>, K | 'arguments', B>;
     returns<ReturnType extends CustomReturnType>(returnType: ReturnType): CustomOperation<SetTypeSubArg<T, 'returnType', ReturnType>, K | 'returns', B>;
+    /**
+     *
+     * @deprecated
+     * `.function` should no longer be used and will be removed
+     * in the next minor version of this package.
+     *
+     * Use `.handler(a.handler.function())` instead
+     */
     function<FunctionRef extends CustomFunctionRefType>(functionRefOrName: FunctionRef): CustomOperation<SetTypeSubArg<T, 'functionRef', FunctionRef>, K | 'function', B>;
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): CustomOperation<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization', B>;
     handler<H extends HandlerInputType>(handlers: H): CustomOperation<T, K | 'handler', B>;

package/lib-esm/src/Handler.d.ts

@@ -1,3 +1,4 @@
+import type { DefineFunction } from '@aws-amplify/data-schema-types';
 import { Brand } from './util';
 import { RefType } from './RefType';
 export type HandlerType = InlineSqlHandler | SqlReferenceHandler | CustomHandler | FunctionHandler;
@@ -37,11 +38,12 @@ export type CustomHandler = {
     [dataSymbol]: CustomHandlerData;
 } & Brand<typeof customHandlerBrand>;
 declare function custom(customHandler: CustomHandlerInput): CustomHandler;
+export type FunctionHandlerData = DefineFunction | string;
 declare const functionHandlerBrand = "functionHandler";
 export type FunctionHandler = {
-    [dataSymbol]: (...args: any[]) => any;
+    [dataSymbol]: FunctionHandlerData;
 } & Brand<typeof functionHandlerBrand>;
-declare function fcn(fn: (...args: any[]) => any): FunctionHandler;
+declare function fcn(fn: FunctionHandlerData): FunctionHandler;
 export declare const handler: {
     inlineSql: typeof inlineSql;
     sqlReference: typeof sqlReference;

package/lib-esm/src/Handler.js

@@ -10,10 +10,13 @@ function getHandlerData(handler) {
     return handler[dataSymbol];
 }
 exports.getHandlerData = getHandlerData;
+//#region handler.inlineSql
 const inlineSqlBrand = 'inlineSql';
 function inlineSql(sql) {
     return { [dataSymbol]: sql, ...buildHandler(inlineSqlBrand) };
 }
+//#endregion
+//#region handler.sqlReference
 const sqlReferenceBrand = 'sqlReference';
 function sqlReference(sqlReference) {
     return { [dataSymbol]: sqlReference, ...buildHandler(sqlReferenceBrand) };
@@ -31,6 +34,7 @@ const functionHandlerBrand = 'functionHandler';
 function fcn(fn) {
     return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };
 }
+//#endregion
 exports.handler = {
     inlineSql,
     sqlReference,

package/lib-esm/src/SchemaProcessor.js

@@ -155,6 +155,27 @@ function refFieldToGql(fieldDef) {
     }
     return field;
 }
+function transformFunctionHandler(handlers, callSignature) {
+    let gqlHandlerContent = '';
+    const lambdaFunctionDefinition = {};
+    handlers.forEach((handler, idx) => {
+        const handlerData = (0, Handler_1.getHandlerData)(handler);
+        if (typeof handlerData === 'string') {
+            gqlHandlerContent += `@function(name: "${handlerData}") `;
+        }
+        else if (typeof handlerData.getInstance === 'function') {
+            const fnBaseName = `Fn_${callSignature}`;
+            const fnNameSuffix = idx === 0 ? '' : `_${idx + 1}`;
+            const fnName = fnBaseName + fnNameSuffix;
+            lambdaFunctionDefinition[fnName] = handlerData;
+            gqlHandlerContent += `@function(name: "${fnName}") `;
+        }
+        else {
+            throw new Error(`Invalid value specified for ${callSignature} handler.function(). Expected: defineFunction or string.`);
+        }
+    });
+    return { gqlHandlerContent, lambdaFunctionDefinition };
+}
 function customOperationToGql(typeName, typeDef, authorization, isCustom = false, databaseType) {
     const { arguments: fieldArgs, returnType, functionRef, handlers, } = typeDef.data;
     let callSignature = typeName;
@@ -184,7 +205,11 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
     const handler = handlers && handlers[0];
     const brand = handler && (0, util_1.getBrand)(handler);
     let gqlHandlerContent = '';
-    if (functionRef) {
+    let lambdaFunctionDefinition = {};
+    if (isFunctionHandler(handlers)) {
+        ({ gqlHandlerContent, lambdaFunctionDefinition } = transformFunctionHandler(handlers, callSignature));
+    }
+    else if (functionRef) {
         gqlHandlerContent = `@function(name: "${functionRef}") `;
     }
     else if (databaseType === 'sql' && handler && brand === 'inlineSql') {
@@ -194,7 +219,7 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
         gqlHandlerContent = `@sql(reference: "${(0, Handler_1.getHandlerData)(handler)}") `;
     }
     const gqlField = `${callSignature}: ${returnTypeName} ${gqlHandlerContent}${authString}`;
-    return { gqlField, models: implicitModels };
+    return { gqlField, models: implicitModels, lambdaFunctionDefinition };
 }
 /**
  * Escape a string that will be used inside of a graphql string.
@@ -692,6 +717,7 @@ const schemaPreprocessor = (schema) => {
     const customMutations = [];
     const customSubscriptions = [];
     const jsFunctions = [];
+    let lambdaFunctions = {};
     const databaseType = schema.data.configuration.database.engine === 'dynamodb'
         ? 'dynamodb'
         : 'sql';
@@ -725,7 +751,8 @@ const schemaPreprocessor = (schema) => {
             }
             else if (isCustomOperation(typeDef)) {
                 const { typeName: opType } = typeDef.data;
-                const { gqlField, models, jsFunctionForField } = transformCustomOperations(typeDef, typeName, mostRelevantAuthRules, databaseType);
+                const { gqlField, models, jsFunctionForField, lambdaFunctionDefinition, } = transformCustomOperations(typeDef, typeName, mostRelevantAuthRules, databaseType);
+                lambdaFunctions = lambdaFunctionDefinition;
                 topLevelTypes.push(...models);
                 if (jsFunctionForField) {
                     jsFunctions.push(jsFunctionForField);
@@ -776,7 +803,12 @@ const schemaPreprocessor = (schema) => {
     };
     gqlModels.push(...generateCustomOperationTypes(customOperations));
     const processedSchema = gqlModels.join('\n\n');
-    return { schema: processedSchema, jsFunctions, functionSchemaAccess };
+    return {
+        schema: processedSchema,
+        jsFunctions,
+        functionSchemaAccess,
+        lambdaFunctions,
+    };
 };
 function validateCustomOperations(typeDef, typeName, authRules) {
     const { functionRef, handlers } = typeDef.data;
@@ -806,6 +838,9 @@ function validateCustomOperations(typeDef, typeName, authRules) {
 const isCustomHandler = (handler) => {
     return Array.isArray(handler) && (0, util_1.getBrand)(handler[0]) === 'customHandler';
 };
+const isFunctionHandler = (handler) => {
+    return Array.isArray(handler) && (0, util_1.getBrand)(handler[0]) === 'functionHandler';
+};
 const normalizeDataSourceName = (dataSource) => {
     // default data source
     const noneDataSourceName = 'NONE_DS';
@@ -867,8 +902,8 @@ function transformCustomOperations(typeDef, typeName, authRules, databaseType) {
         jsFunctionForField = handleCustom(handlers, opType, typeName);
     }
     const isCustom = Boolean(jsFunctionForField);
-    const { gqlField, models } = customOperationToGql(typeName, typeDef, authRules, isCustom, databaseType);
-    return { gqlField, models, jsFunctionForField };
+    const { gqlField, models, lambdaFunctionDefinition } = customOperationToGql(typeName, typeDef, authRules, isCustom, databaseType);
+    return { gqlField, models, jsFunctionForField, lambdaFunctionDefinition };
 }
 function generateCustomOperationTypes({ queries, mutations, subscriptions, }) {
     const types = [];
@@ -889,7 +924,13 @@ function generateCustomOperationTypes({ queries, mutations, subscriptions, }) {
  * @returns DerivedApiDefinition that conforms to IAmplifyGraphqlDefinition
  */
 function processSchema(arg) {
-    const { schema, jsFunctions, functionSchemaAccess } = schemaPreprocessor(arg.schema);
-    return { schema, functionSlots: [], jsFunctions, functionSchemaAccess };
+    const { schema, jsFunctions, functionSchemaAccess, lambdaFunctions } = schemaPreprocessor(arg.schema);
+    return {
+        schema,
+        functionSlots: [],
+        jsFunctions,
+        functionSchemaAccess,
+        lambdaFunctions,
+    };
 }
 exports.processSchema = processSchema;