@aws-amplify/data-schema 0.13.14 → 0.13.16

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

@@ -4,7 +4,7 @@ import type { ResolveSchema, SchemaTypes } from './MappedTypes/ResolveSchema';
 import type { CreateImplicitModelsFromRelations, ResolveFieldProperties } from './MappedTypes/ResolveFieldProperties';
 import type { ModelIdentifier, ModelSecondaryIndexes, RelationalMetadata } from './MappedTypes/ModelMetadata';
 import type { ExtractNonModelTypes, NonModelTypesShape } from './MappedTypes/ExtractNonModelTypes';
-import type { ResolveCustomOperations } from './MappedTypes/CustomOperations';
+import { ResolveCustomOperations, CustomOperationHandlerTypes } from './MappedTypes/CustomOperations';
 export type ClientSchema<Schema extends ModelSchema<any, any>> = InternalClientSchema<Schema>;
 /**
  * Types for unwrapping generic type args into client-consumable types
@@ -28,7 +28,7 @@ type InternalClientSchema<Schema extends ModelSchema<any, any>, NonModelTypes ex
     [ImplicitModel in keyof ImplicitModels]: {
         identifier: 'id';
     };
-}, ResolvedFields extends Record<string, unknown> = ResolveFieldProperties<Schema, NonModelTypes, ImplicitModels>, IdentifierMeta extends Record<string, any> = ModelIdentifier<SchemaTypes<Schema>>, SecondaryIndexes extends Record<string, any> = ModelSecondaryIndexes<SchemaTypes<Schema>>> = ResolvedFields & {
+}, ResolvedFields extends Record<string, unknown> = ResolveFieldProperties<Schema, NonModelTypes, ImplicitModels>, IdentifierMeta extends Record<string, any> = ModelIdentifier<SchemaTypes<Schema>>, SecondaryIndexes extends Record<string, any> = ModelSecondaryIndexes<SchemaTypes<Schema>>> = ResolvedFields & CustomOperationHandlerTypes<ResolveCustomOperations<Schema, ResolvedFields, NonModelTypes>['customOperations']> & ResolvedFields & {
     [__modelMeta__]: IdentifierMeta & ImplicitModelsIdentifierMeta & SecondaryIndexes & RelationalMetadata<ResolvedSchema, ResolvedFields, IdentifierMeta> & NonModelTypes & ResolveCustomOperations<Schema, ResolvedFields, NonModelTypes>;
 };
 export {};

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

@@ -4,6 +4,7 @@ import type { CustomOperation, CustomOperationParamShape } from '../CustomOperat
 import type { ModelField } from '../ModelField';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
+import type { AppSyncResolverHandler } from 'aws-lambda';
 /**
  * Creates meta types for custom operations from a schema.
  */
@@ -44,3 +45,78 @@ export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyRes
  * with the addition that allows .ref() a model with custom operations.
  */
 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>;
+/**
+ * The kind of shape we need to map to custom handler (e.g., lambda) function
+ * signatures.
+ */
+type CustomOperationsMap = Record<string, CustomOperationMinimalDef>;
+/**
+ * The minimal amount of structure needed to extract types for a custom handler.
+ */
+type CustomOperationMinimalDef = {
+    arguments: any;
+    returnType: any;
+};
+/**
+ * Derives the signature and types for a lambda handler for a particular
+ * custom Query or Mutation from a Schema.
+ */
+type IndvidualCustomHandlerTypes<Op extends CustomOperationMinimalDef> = {
+    /**
+     * Handler type for lambda function implementations. E.g.,
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // event and context will be fully typed inside here.
+     * }
+     * ```
+     */
+    functionHandler: AppSyncResolverHandler<Op['arguments'], LambdaReturnType<Op['returnType']>>;
+    /**
+     * The `context.arguments` type for lambda function implementations.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Provides this type, if needed:
+     *  const args: Schema['echo']['functionHandlerArguments'] = event.arguments;
+     * }
+     * ```
+     */
+    functionHandlerArguments: Op['arguments'];
+    /**
+     * The return type expected by a lambda function handler.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Result type enforced here:
+     *  const result: Schema['echo']['functionHandlerResult'] = buildResult(...);
+     *
+     *  // `Result` type matches expected function return type here:
+     *  return result;
+     * }
+     * ```
+     */
+    functionHandlerResult: LambdaReturnType<Op['returnType']>;
+};
+/**
+ * Derives the function signatures for a lambda handlers for all the provided
+ * custom queries and mutations.
+ */
+export type CustomOperationHandlerTypes<CustomOperations extends CustomOperationsMap> = {
+    [K in keyof CustomOperations]: IndvidualCustomHandlerTypes<CustomOperations[K]>;
+};
+/**
+ * Returns a return type with lazy loaders removed.
+ *
+ * (Custom handlers should not return lazy loaded fields -- they're *lazy loaded*.)
+ */
+type LambdaReturnType<T> = T extends Record<string, any> ? {
+    [K in keyof Exclude<T, null | undefined> as Exclude<T, null | undefined>[K] extends (...args: any) => any ? never : K]: Exclude<T, null | undefined>[K];
+} : T | (null extends T ? null : never) | (undefined extends T ? undefined : never);
+export {};

package/lib-esm/src/SchemaProcessor.js

@@ -164,8 +164,8 @@ function transformFunctionHandler(handlers, callSignature) {
             gqlHandlerContent += `@function(name: "${handlerData}") `;
         }
         else if (typeof handlerData.getInstance === 'function') {
-            const fnBaseName = `Fn_${callSignature}`;
-            const fnNameSuffix = idx === 0 ? '' : `_${idx + 1}`;
+            const fnBaseName = `Fn${capitalize(callSignature)}`;
+            const fnNameSuffix = idx === 0 ? '' : `${idx + 1}`;
             const fnName = fnBaseName + fnNameSuffix;
             lambdaFunctionDefinition[fnName] = handlerData;
             gqlHandlerContent += `@function(name: "${fnName}") `;
@@ -271,6 +271,27 @@ function addFields(existing, additions) {
         }
     }
 }
+/**
+ * Validate that no implicit fields are used by the model definition
+ *
+ * @param existing An existing field map
+ * @param implicitFields A field map inferred from other schema usage
+ *
+ * @throws An error when an undefined field is used or when a field is used in a way that conflicts with its generated definition
+ */
+function validateStaticFields(existing, implicitFields) {
+    if (implicitFields === undefined) {
+        return;
+    }
+    for (const [k, field] of Object.entries(implicitFields)) {
+        if (!existing[k]) {
+            throw new Error(`Field ${k} isn't defined.`);
+        }
+        else if (areConflicting(existing[k], field)) {
+            throw new Error(`Field ${k} defined twice with conflicting definitions.`);
+        }
+    }
+}
 /**
  * Produces a new field definition object from every field definition object
  * given as an argument. Performs validation (conflict detection) as objects
@@ -721,6 +742,7 @@ const schemaPreprocessor = (schema) => {
     const databaseType = schema.data.configuration.database.engine === 'dynamodb'
         ? 'dynamodb'
         : 'sql';
+    const staticSchema = schema.data.configuration.database.engine === 'dynamodb' ? false : true;
     const fkFields = allImpliedFKs(schema);
     const topLevelTypes = Object.entries(schema.data.types);
     const { schemaAuth, functionSchemaAccess } = extractFunctionSchemaAccess(schema.data.authorization);
@@ -772,6 +794,23 @@ const schemaPreprocessor = (schema) => {
                 }
             }
         }
+        else if (staticSchema) {
+            const fields = { ...typeDef.data.fields };
+            const identifier = typeDef.data.identifier;
+            const [partitionKey] = identifier;
+            validateStaticFields(fields, fkFields[typeName]);
+            const { authString, authFields } = calculateAuth(mostRelevantAuthRules);
+            if (authString == '') {
+                throw new Error(`Model \`${typeName}\` is missing authorization rules. Add global rules to the schema or ensure every model has its own rules.`);
+            }
+            const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
+            validateStaticFields(fields, authFields);
+            const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey);
+            topLevelTypes.push(...models);
+            const joined = gqlFields.join('\n  ');
+            const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;
+            gqlModels.push(model);
+        }
         else {
             const fields = mergeFieldObjects(typeDef.data.fields, fkFields[typeName]);
             const identifier = typeDef.data.identifier;