@aws-amplify/data-schema 0.13.9 → 0.13.11

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

@@ -1,4 +1,4 @@
-import type { UnionToIntersection } from '@aws-amplify/data-schema-types';
+import type { UnionToIntersection, FunctionSchemaAccess } from '@aws-amplify/data-schema-types';
 declare const __data: unique symbol;
 /**
  * All possible providers.
@@ -41,6 +41,24 @@ export type Strategy = (typeof Strategies)[number];
  */
 export declare const Operations: readonly ["create", "update", "delete", "read", "get", "list", "sync", "listen", "search"];
 export type Operation = (typeof Operations)[number];
+/**
+ * The operations that can be performed against an API by a Lambda function.
+ */
+export declare const ResourceOperations: readonly ["query", "mutate", "listen"];
+export type ResourceOperation = (typeof ResourceOperations)[number];
+/**
+ * Super-set of regular auth type; includes schema-level resource access configuration
+ */
+export type SchemaAuthorization<AuthStrategy extends Strategy, AuthField extends string | undefined, AuthFieldPlurality extends boolean> = Authorization<AuthStrategy, AuthField, AuthFieldPlurality> | ResourceAuthorization;
+export type ResourceAuthorization = {
+    [__data]: ResourceAuthorizationData;
+};
+type DefineFunction = FunctionSchemaAccess['resourceProvider'];
+export type ResourceAuthorizationData = {
+    strategy: 'resource';
+    resource: DefineFunction;
+    operations?: ResourceOperation[];
+};
 export type Authorization<AuthStrategy extends Strategy, AuthField extends string | undefined, AuthFieldPlurality extends boolean> = {
     [__data]: {
         strategy?: AuthStrategy;
@@ -200,7 +218,11 @@ export declare const allow: {
     readonly custom: (provider?: CustomProvider) => Authorization<"custom", undefined, false> & {
         to: typeof to;
     };
+    readonly resource: (fn: DefineFunction) => ResourceAuthorization & {
+        to: typeof resourceTo;
+    };
 };
+declare function resourceTo<SELF extends ResourceAuthorization>(this: SELF, operations: ResourceOperation[]): Omit<SELF, "to">;
 /**
  * Turns the type from a list of `Authorization` rules like this:
  *
@@ -261,4 +283,5 @@ export declare const accessData: <T extends Authorization<any, any, any>>(author
     identityClaim?: string | undefined;
     groupClaim?: string | undefined;
 };
+export declare const accessSchemaData: <T extends SchemaAuthorization<any, any, any>>(authorization: T) => T[typeof __data];
 export {};

package/lib-esm/src/Authorization.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.accessData = exports.allow = exports.Operations = exports.Strategies = exports.CustomProviders = exports.GroupProviders = exports.OwnerProviders = exports.PrivateProviders = exports.PublicProviders = exports.Providers = void 0;
+exports.accessSchemaData = exports.accessData = exports.allow = exports.ResourceOperations = exports.Operations = exports.Strategies = exports.CustomProviders = exports.GroupProviders = exports.OwnerProviders = exports.PrivateProviders = exports.PublicProviders = exports.Providers = void 0;
 const __data = Symbol('data');
 /**
  * All possible providers.
@@ -57,6 +57,10 @@ exports.Operations = [
     'listen',
     'search',
 ];
+/**
+ * The operations that can be performed against an API by a Lambda function.
+ */
+exports.ResourceOperations = ['query', 'mutate', 'listen'];
 /**
  * Creates a shallow copy of an object with an individual field pruned away.
  *
@@ -302,6 +306,27 @@ exports.allow = {
             to,
         });
     },
+    resource(fn) {
+        return resourceAuthData(fn, {
+            to: resourceTo,
+        });
+    },
 };
+function resourceTo(operations) {
+    this[__data].operations = operations;
+    return omit(this, 'to');
+}
+function resourceAuthData(resource, builderMethods) {
+    return {
+        [__data]: {
+            strategy: 'resource',
+            resource,
+        },
+        ...builderMethods,
+    };
+}
 const accessData = (authorization) => authorization[__data];
 exports.accessData = accessData;
+// TODO: delete when we make resource auth available at each level in the schema (model, field)
+const accessSchemaData = (authorization) => authorization[__data];
+exports.accessSchemaData = accessSchemaData;

package/lib-esm/src/MappedTypes/CustomOperations.d.ts

@@ -2,7 +2,8 @@ import type { ModelSchema } from '../ModelSchema';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 import type { ModelField } from '../ModelField';
-import { RefType, RefTypeParamShape } from '../RefType';
+import type { RefType, RefTypeParamShape } from '../RefType';
+import type { ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
 /**
  * Creates meta types for custom operations from a schema.
  */
@@ -10,7 +11,7 @@ export type ResolveCustomOperations<Schema extends ModelSchema<any, any>, FullyR
     customOperations: {
         [OpName in keyof CustomOpShapes<Schema>]: {
             arguments: CustomOpArguments<CustomOpShapes<Schema>[OpName]>;
-            returnType: CustomOpReturnType<CustomOpShapes<Schema>[OpName], Bag<FullyResolvedSchema, NonModelTypes>>;
+            returnType: CustomOpReturnType<CustomOpShapes<Schema>[OpName], FullyResolvedSchema, NonModelTypes>;
             functionRef: CustomOpShapes<Schema>[OpName]['functionRef'];
             typeName: CustomOpShapes<Schema>[OpName]['typeName'];
             authorization: CustomOpShapes<Schema>[OpName]['authorization'];
@@ -34,14 +35,12 @@ export type CustomOpArguments<Shape extends CustomOperationParamShape> = {
  *
  * This entails dereferencing refs and inferring graphql types from field-type defs.
  */
-export type CustomOpReturnType<Shape extends CustomOperationParamShape, Bag extends Record<string, unknown>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? ResolveRef<RefShape, Bag> : Shape['returnType'] extends ModelField<infer R, any, any> ? R : never;
+export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes> : Shape['returnType'] extends ModelField<infer R, any, any> ? R : never;
 /**
  * `a.ref()` resolution specific to custom operations, for which `a.ref()`
  * can refer to a model, custom type, or enum.
+ *
+ * This utility is a duplication of ResolveRef (src/MappedTypes/ResolveFieldProperties.ts)
+ * with the addition that allows .ref() a model with custom operations.
  */
-export type ResolveRef<Shape extends RefTypeParamShape, Bag extends Record<string, unknown>> = Shape['link'] extends keyof Bag ? Shape['required'] extends true ? Bag[Shape['link']] : Bag[Shape['link']] | null : never;
-/**
- * Small utility to provided a merged view of models, custom types, and enums
- * from a schema and nonModel-types.
- */
-export type Bag<FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape> = FullyResolvedSchema & NonModelTypes['customTypes'] & NonModelTypes['enums'];
+export type ResolveRef<Shape extends RefTypeParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, Link = Shape['link'], RefValue = Link extends keyof FullyResolvedSchema ? FullyResolvedSchema[Link] : Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never, Value = Shape['valueRequired'] extends true ? RefValue : RefValue | null> = ResolveRefValueArrayTraits<Shape, Value>;

package/lib-esm/src/MappedTypes/ResolveFieldProperties.d.ts

@@ -28,10 +28,15 @@ type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationalFi
 type ResolveRelationalFieldsForModel<Schema, ModelName extends keyof Schema, Flat extends boolean> = {
     [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationalFieldParamShape ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelName][FieldName]['relatedModel'], Schema[ModelName][FieldName], Flat> : never : Schema[ModelName][FieldName];
 };
-export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], Value = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never> = Ref['required'] extends true ? Value : Value | null;
-type ResolveRefsOfCustomType<NonModelTypes extends NonModelTypesShape, T> = {
+export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], RefValue = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never, Value = Ref['valueRequired'] extends true ? RefValue : RefValue | null> = ResolveRefValueArrayTraits<Ref, Value>;
+/**
+ * Converts the resolved RefType Value type into Array<> according to the
+ * `array` and `arrayRequired` properties of the RefType
+ */
+export type ResolveRefValueArrayTraits<Ref extends RefTypeParamShape, Value> = Ref['array'] extends false ? Value : Ref['arrayRequired'] extends true ? Array<Value> : Array<Value> | null;
+export type ResolveRefsOfCustomType<NonModelTypes extends NonModelTypesShape, T> = {
     [Prop in keyof T]: T[Prop] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : T[Prop];
-} extends infer Resolved ? ExtractNullableFieldsToOptionalFields<Resolved> & ExtractNonNullableFieldsToRequiredFields<Resolved> : never;
+} extends infer Resolved ? Intersection<ExtractNullableFieldsToOptionalFields<Resolved>, ExtractNonNullableFieldsToRequiredFields<Resolved>> : never;
 type ResolveRelationships<Schema, NonModelTypes extends NonModelTypesShape, Flat extends boolean = false> = {
     [ModelProp in keyof Schema]: {
         [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? Schema[ModelProp][FieldProp]['relationshipType'] extends 'manyToMany' ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relationName'], Schema[ModelProp][FieldProp], Flat> : never : GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
@@ -54,7 +59,7 @@ type ExtractNonNullableFieldsToRequiredFields<Fields> = {
 type MarkModelsNonNullableFieldsRequired<Schema> = {
     [ModelProp in keyof Schema]: ExtractNonNullableFieldsToRequiredFields<Schema[ModelProp]>;
 };
-type Intersection<A, B, C, D> = A & B & C & D extends infer U ? {
+type Intersection<A = Record<never, never>, B = Record<never, never>, C = Record<never, never>, D = Record<never, never>> = A & B & C & D extends infer U ? {
     [P in keyof U]: U[P];
 } : never;
 export type ModelImpliedAuthFields<Schema extends ModelSchema<any, any>> = {

package/lib-esm/src/MappedTypes/ResolveSchema.d.ts

@@ -32,10 +32,12 @@ export type ModelAndCustomTypes<Schema> = {
  */
 export type FieldTypes<T> = {
     [ModelProp in keyof T]: {
-        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<ModelProp & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
-            required: false;
+            valueRequired: false;
+            array: false;
+            arrayRequired: false;
             authorization: [];
         }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : never;
     };
@@ -50,10 +52,12 @@ export type FieldTypes<T> = {
  */
 export type FieldTypesOfCustomType<T> = {
     [CustomTypeName in keyof T]: {
-        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<infer R, any, any> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<infer R, any, any> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<CustomTypeName & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
-            required: false;
+            valueRequired: false;
+            array: false;
+            arrayRequired: false;
             authorization: [];
         }> | null : never;
     };

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

@@ -3,7 +3,7 @@ import { type ModelType, type ModelTypeParamShape, type InternalModel, SchemaMod
 import type { EnumType, EnumTypeParamShape } from './EnumType';
 import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type { CustomOperation, CustomOperationParamShape, InternalCustom, MutationCustomOperation, QueryCustomOperation, SubscriptionCustomOperation } from './CustomOperation';
-import { Authorization } from './Authorization';
+import { SchemaAuthorization } from './Authorization';
 type SchemaContent = ModelType<ModelTypeParamShape, any> | CustomType<CustomTypeParamShape> | EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any>;
 type ModelSchemaContents = Record<string, SchemaContent>;
 type InternalSchemaModels = Record<string, InternalModel | EnumType<any> | CustomType<any> | InternalCustom>;
@@ -35,7 +35,7 @@ export type SchemaConfig<DE extends DatasourceEngine, DC extends DatasourceConfi
 };
 export type ModelSchemaParamShape = {
     types: ModelSchemaContents;
-    authorization: Authorization<any, any, any>[];
+    authorization: SchemaAuthorization<any, any, any>[];
     configuration: SchemaConfig<any, any>;
 };
 export type SQLModelSchemaParamShape = ModelSchemaParamShape & {
@@ -44,11 +44,11 @@ export type SQLModelSchemaParamShape = ModelSchemaParamShape & {
 export type InternalSchema = {
     data: {
         types: InternalSchemaModels;
-        authorization: Authorization<any, any, any>[];
+        authorization: SchemaAuthorization<any, any, any>[];
     };
 };
 export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'authorization' = never> = Omit<{
-    authorization: <AuthRules extends Authorization<any, any, any>>(auth: AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
+    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(auth: AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
 }, UsedMethods> & {
     data: T;
     models: {

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

@@ -6,20 +6,28 @@ declare const brandName = "ref";
 type RefTypeData = {
     type: 'ref';
     link: string;
-    required: boolean;
+    valueRequired: boolean;
+    array: boolean;
+    arrayRequired: boolean;
     authorization: Authorization<any, any, any>[];
 };
 export type RefTypeParamShape = {
     type: 'ref';
     link: string;
-    required: boolean;
+    valueRequired: boolean;
+    array: boolean;
+    arrayRequired: boolean;
     authorization: Authorization<any, any, any>[];
 };
 export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = never, Auth = undefined> = Omit<{
     /**
      * Marks a field as required.
      */
-    required(): RefType<SetTypeSubArg<T, 'required', true>, K | 'required'>;
+    required(): RefType<SetTypeSubArg<T, T['array'] extends true ? 'arrayRequired' : 'valueRequired', true>, K | 'required'>;
+    /**
+     * Marks a field as an array of the specified ref type.
+     */
+    array(): RefType<SetTypeSubArg<T, 'array', true>, Exclude<K, 'required'> | 'array'>;
     /**
      * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
      * multiple authorization rules for this field.
@@ -38,7 +46,9 @@ export type InternalRef = RefType<RefTypeParamShape> & {
 type RefTypeArgFactory<Link extends string> = {
     type: 'ref';
     link: Link;
-    required: false;
+    valueRequired: false;
+    array: false;
+    arrayRequired: false;
     authorization: [];
 };
 export declare function ref<Value extends string, T extends Value>(link: T): RefType<RefTypeArgFactory<T>, never, undefined>;

package/lib-esm/src/RefType.js

@@ -10,12 +10,23 @@ function _ref(link) {
     const data = {
         type: 'ref',
         link,
-        required: false,
+        valueRequired: false,
+        array: false,
+        arrayRequired: false,
         authorization: [],
     };
     const builder = brandedBuilder({
         required() {
-            data.required = true;
+            if (data.array) {
+                data.arrayRequired = true;
+            }
+            else {
+                data.valueRequired = true;
+            }
+            return this;
+        },
+        array() {
+            data.array = true;
             return this;
         },
         authorization(rules) {

package/lib-esm/src/SchemaProcessor.js

@@ -142,17 +142,17 @@ function modelFieldToGql(fieldDef) {
     return field;
 }
 function refFieldToGql(fieldDef) {
-    const { link, required } = fieldDef;
+    const { link, valueRequired, array, arrayRequired } = fieldDef;
     let field = link;
-    if (required === true) {
+    if (valueRequired === true) {
+        field += '!';
+    }
+    if (array === true) {
+        field = `[${field}]`;
+    }
+    if (arrayRequired === true) {
         field += '!';
     }
-    // if (array) {
-    //   field = `[${field}]`;
-    // }
-    // if (arrayRequired === true) {
-    //   field += '!';
-    // }
     return field;
 }
 function customOperationToGql(typeName, typeDef, authorization, isCustom = false) {
@@ -243,6 +243,18 @@ function mergeFieldObjects(...fieldsObjects) {
     }
     return result;
 }
+/**
+ * Throws if resource/lambda auth is configured at the model or field level
+ *
+ * @param authorization A list of authorization rules.
+ */
+function validateAuth(authorization = []) {
+    for (const entry of authorization) {
+        if (ruleIsResourceAuth(entry)) {
+            throw new Error('Lambda resource authorization is only confiugrable at the schema level');
+        }
+    }
+}
 /**
  * Given a list of authorization rules, produces a set of the implied owner and/or
  * group fields, along with the associated graphql `@auth` string directive.
@@ -530,7 +542,9 @@ const idFields = (model) => {
 function processFieldLevelAuthRules(fields, authFields) {
     const fieldLevelAuthRules = {};
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
-        const { authString, authFields: fieldAuthField } = calculateAuth(fieldDef?.data?.authorization || []);
+        const fieldAuth = fieldDef?.data?.authorization || [];
+        validateAuth(fieldAuth);
+        const { authString, authFields: fieldAuthField } = calculateAuth(fieldAuth);
         if (authString)
             fieldLevelAuthRules[fieldName] = authString;
         if (fieldAuthField) {
@@ -621,6 +635,38 @@ const transformedSecondaryIndexesForModel = (secondaryIndexes) => {
         return acc;
     }, {});
 };
+const ruleIsResourceAuth = (authRule) => {
+    const data = (0, Authorization_1.accessSchemaData)(authRule);
+    return data.strategy === 'resource';
+};
+/**
+ * Separates out lambda resource auth rules from remaining schema rules.
+ *
+ * @param authRules schema auth rules
+ */
+const extractFunctionSchemaAccess = (authRules) => {
+    const schemaAuth = [];
+    const functionSchemaAccess = [];
+    const defaultActions = [
+        'query',
+        'mutate',
+        'listen',
+    ];
+    for (const rule of authRules) {
+        if (ruleIsResourceAuth(rule)) {
+            const ruleData = (0, Authorization_1.accessSchemaData)(rule);
+            const fnAccess = {
+                resourceProvider: ruleData.resource,
+                actions: ruleData.operations || defaultActions,
+            };
+            functionSchemaAccess.push(fnAccess);
+        }
+        else {
+            schemaAuth.push(rule);
+        }
+    }
+    return { schemaAuth, functionSchemaAccess };
+};
 const schemaPreprocessor = (schema) => {
     const gqlModels = [];
     const customQueries = [];
@@ -629,10 +675,12 @@ const schemaPreprocessor = (schema) => {
     const jsFunctions = [];
     const fkFields = allImpliedFKs(schema);
     const topLevelTypes = Object.entries(schema.data.types);
+    const { schemaAuth, functionSchemaAccess } = extractFunctionSchemaAccess(schema.data.authorization);
     for (const [typeName, typeDef] of topLevelTypes) {
+        validateAuth(typeDef.data?.authorization);
         const mostRelevantAuthRules = typeDef.data?.authorization?.length > 0
             ? typeDef.data.authorization
-            : schema.data.authorization;
+            : schemaAuth;
         if (!isInternalModel(typeDef)) {
             if (isEnumType(typeDef)) {
                 if (typeDef.values.some((value) => /\s/.test(value))) {
@@ -706,7 +754,7 @@ const schemaPreprocessor = (schema) => {
     };
     gqlModels.push(...generateCustomOperationTypes(customOperations));
     const processedSchema = gqlModels.join('\n\n');
-    return { schema: processedSchema, jsFunctions };
+    return { schema: processedSchema, jsFunctions, functionSchemaAccess };
 };
 function validateCustomOperations(typeDef, typeName, authRules) {
     const { functionRef, handlers } = typeDef.data;
@@ -819,7 +867,7 @@ function generateCustomOperationTypes({ queries, mutations, subscriptions, }) {
  * @returns DerivedApiDefinition that conforms to IAmplifyGraphqlDefinition
  */
 function processSchema(arg) {
-    const { schema, jsFunctions } = schemaPreprocessor(arg.schema);
-    return { schema, functionSlots: [], jsFunctions };
+    const { schema, jsFunctions, functionSchemaAccess } = schemaPreprocessor(arg.schema);
+    return { schema, functionSlots: [], jsFunctions, functionSchemaAccess };
 }
 exports.processSchema = processSchema;