@aws-amplify/data-schema 0.14.2 → 0.14.4

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

@@ -25,16 +25,21 @@ type BackendSecret = {
     resolvePath: (backendIdentifier: any) => any;
 };
 export type DatasourceEngine = 'mysql' | 'postgresql' | 'dynamodb';
+type SubnetAZ = {
+    subnetId: string;
+    availabilityZone: string;
+};
+type VpcConfig = {
+    vpcId: string;
+    securityGroupIds: string[];
+    subnetAvailabilityZones: SubnetAZ[];
+};
 type DatasourceConfig<DE extends DatasourceEngine> = DE extends 'dynamodb' ? {
     engine: DE;
 } : {
     engine: DE;
-    hostname: BackendSecret;
-    username: BackendSecret;
-    password: BackendSecret;
-    port: BackendSecret;
-    databaseName: BackendSecret;
-    vpcConfig?: Record<string, never>;
+    connectionUri: BackendSecret;
+    vpcConfig?: VpcConfig;
 };
 export type SchemaConfig<DE extends DatasourceEngine, DC extends DatasourceConfig<DE>> = {
     database: DC;

package/lib-esm/src/SchemaProcessor.js

@@ -198,7 +198,7 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
         throw new Error(`Unrecognized return type on ${typeName}`);
     }
     if (Object.keys(fieldArgs).length > 0) {
-        const { gqlFields, models } = processFields(typeName, fieldArgs, {});
+        const { gqlFields, models } = processFields(typeName, fieldArgs, {}, {});
         callSignature += `(${gqlFields.join(', ')})`;
         implicitModels.push(...models);
     }
@@ -307,6 +307,24 @@ function validateStaticFields(existing, implicitFields) {
         }
     }
 }
+/**
+ * Validate that no implicit fields conflict with explicitly defined fields.
+ *
+ * @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 validateImpliedFields(existing, implicitFields) {
+    if (implicitFields === undefined) {
+        return;
+    }
+    for (const [k, field] of Object.entries(implicitFields)) {
+        if (existing[k] && areConflicting(existing[k], field)) {
+            throw new Error(`Implicit field ${k} conflicts with the explicit field definition.`);
+        }
+    }
+}
 /**
  * Produces a new field definition object from every field definition object
  * given as an argument. Performs validation (conflict detection) as objects
@@ -344,7 +362,8 @@ function validateAuth(authorization = []) {
  *
  * The computed directives are intended to be appended to the graphql field definition.
  *
- * The computed fields are intended to be aggregated and injected per model.
+ * The computed fields will be used to confirm no conflicts between explicit field definitions
+ * and implicit auth fields.
  *
  * @param authorization A list of authorization rules.
  * @returns
@@ -590,35 +609,6 @@ const allImpliedFKs = (schema) => {
     }
     return fks;
 };
-/**
- * Determines if implicit date fields are in effect for a given model. If they are,
- * returns those implicit fields.
- *
- * NOTE: For now, we *only* support the default implicit fields.
- *
- * @param _model Model to find date fields for.
- */
-const implicitTimestampFields = (_model) => {
-    return {
-        createdAt: (0, ModelField_1.datetime)().required(),
-        updatedAt: (0, ModelField_1.datetime)().required(),
-    };
-};
-/**
- * Generates default Pk fields for a model, based on identifier designation.
- *
- * The fields from this function are just default values. They should be overridden
- * by ID field definitions that are explicit in the model.
- *
- * @param _model Model to find PK fields for.
- */
-const idFields = (model) => {
-    const fields = {};
-    for (const fieldName of model.data.identifier) {
-        fields[fieldName] = (0, ModelField_1.id)().required();
-    }
-    return fields;
-};
 function processFieldLevelAuthRules(fields, authFields) {
     const fieldLevelAuthRules = {};
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
@@ -633,9 +623,10 @@ function processFieldLevelAuthRules(fields, authFields) {
     }
     return fieldLevelAuthRules;
 }
-function processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
+function processFields(typeName, fields, impliedFields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
     const gqlFields = [];
     const models = [];
+    validateImpliedFields(fields, impliedFields);
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
         const fieldAuth = fieldLevelAuthRules[fieldName]
             ? ` ${fieldLevelAuthRules[fieldName]}`
@@ -806,7 +797,7 @@ const schemaPreprocessor = (schema) => {
                 const authString = '';
                 const authFields = {};
                 const fieldLevelAuthRules = processFieldLevelAuthRules(fieldAuthApplicableFields, authFields);
-                const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules);
+                const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules);
                 topLevelTypes.push(...models);
                 const joined = gqlFields.join('\n  ');
                 const model = `type ${typeName} ${authString}\n{\n  ${joined}\n}`;
@@ -846,7 +837,7 @@ const schemaPreprocessor = (schema) => {
             }
             const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
             validateStaticFields(fields, authFields);
-            const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey);
+            const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules, identifier, partitionKey);
             topLevelTypes.push(...models);
             const joined = gqlFields.join('\n  ');
             const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;
@@ -862,14 +853,7 @@ const schemaPreprocessor = (schema) => {
                 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);
-            const { gqlFields, models } = processFields(typeName, {
-                // ID fields are not merged outside `mergeFieldObjects` to skip
-                // validation, because the `identifer()` method doesn't specify or
-                // care what the underlying field type is. We should always just defer
-                // to whatever is explicitly defined if there's an overlap.
-                ...idFields(typeDef),
-                ...mergeFieldObjects(fields, authFields, implicitTimestampFields(typeDef)),
-            }, fieldLevelAuthRules, identifier, partitionKey, transformedSecondaryIndexes);
+            const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules, identifier, partitionKey, transformedSecondaryIndexes);
             topLevelTypes.push(...models);
             const joined = gqlFields.join('\n  ');
             const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;