@aws-amplify/data-schema 0.11.0

package/lib-esm/src/SchemaProcessor.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSchema = void 0;
+const ModelField_1 = require("./ModelField");
+const ModelRelationalField_1 = require("./ModelRelationalField");
+const Authorization_1 = require("./Authorization");
+function isInternalModel(model) {
+    if (model.data && model.data?.type !== 'customType') {
+        return true;
+    }
+    return false;
+}
+function isEnumType(data) {
+    if (data?.type === 'enum') {
+        return true;
+    }
+    return false;
+}
+function isCustomType(data) {
+    if (data?.data?.type === 'customType') {
+        return true;
+    }
+    return false;
+}
+function isModelFieldDef(data) {
+    return data?.fieldType === 'model';
+}
+function isScalarFieldDef(data) {
+    return data?.fieldType !== 'model';
+}
+function isRefFieldDef(data) {
+    return data?.type === 'ref';
+}
+function isModelField(field) {
+    return isModelFieldDef(field.data);
+}
+function isScalarField(field) {
+    return isScalarFieldDef(field.data);
+}
+function isRefField(field) {
+    return isRefFieldDef(field.data);
+}
+function scalarFieldToGql(fieldDef, identifier) {
+    const { fieldType, required, array, arrayRequired, default: _default, } = fieldDef;
+    let field = fieldType;
+    if (identifier !== undefined) {
+        field += '!';
+        if (identifier.length > 1) {
+            const [_pk, ...sk] = identifier;
+            field += ` @primaryKey(sortKeyFields: ${JSON.stringify(sk)})`;
+        }
+        else {
+            field += ' @primaryKey';
+        }
+        return field;
+    }
+    if (required === true) {
+        field += '!';
+    }
+    if (array) {
+        field = `[${field}]`;
+        if (arrayRequired === true) {
+            field += '!';
+        }
+    }
+    if (_default !== undefined) {
+        field += ` @default(value: "${_default?.toString()}")`;
+    }
+    return field;
+}
+function modelFieldToGql(fieldDef) {
+    const { type, relatedModel, array, relationName, valueRequired, arrayRequired, } = fieldDef;
+    let field = relatedModel;
+    if (valueRequired === true) {
+        field += '!';
+    }
+    if (array) {
+        field = `[${field}]`;
+    }
+    if (arrayRequired === true) {
+        field += '!';
+    }
+    field += ` @${type}`;
+    // TODO: accept other relationship options e.g. `fields`
+    if (type === 'manyToMany') {
+        field += `(relationName: "${relationName}")`;
+    }
+    return field;
+}
+function refFieldToGql(fieldDef) {
+    const { link, required } = fieldDef;
+    let field = link;
+    if (required === true) {
+        field += '!';
+    }
+    // if (array) {
+    //   field = `[${field}]`;
+    // }
+    // if (arrayRequired === true) {
+    //   field += '!';
+    // }
+    return field;
+}
+function calculateAuth(authorization) {
+    const authFields = {};
+    const rules = [];
+    for (const entry of authorization) {
+        const rule = (0, Authorization_1.accessData)(entry);
+        const ruleParts = [];
+        if (rule.strategy) {
+            ruleParts.push([`allow: ${rule.strategy}`]);
+        }
+        else {
+            return {
+                authFields,
+                authString: '',
+            };
+        }
+        if (rule.provider) {
+            ruleParts.push(`provider: ${rule.provider}`);
+        }
+        if (rule.operations) {
+            ruleParts.push(`operations: [${rule.operations.join(', ')}]`);
+        }
+        if (rule.groupOrOwnerField) {
+            // directive attribute, depending whether it's owner or group auth
+            if (rule.strategy === 'groups') {
+                // does this need to be escaped?
+                ruleParts.push(`groupsField: "${rule.groupOrOwnerField}"`);
+            }
+            else {
+                // does this need to be escaped?
+                ruleParts.push(`ownerField: "${rule.groupOrOwnerField}"`);
+            }
+            // model field dep, type of which depends on whether multiple owner/group
+            // is required.
+            if (rule.multiOwner) {
+                authFields[rule.groupOrOwnerField] = (0, ModelField_1.string)().array();
+            }
+            else {
+                authFields[rule.groupOrOwnerField] = (0, ModelField_1.string)();
+            }
+        }
+        if (rule.groups) {
+            // does `group` need to be escaped?
+            ruleParts.push(`groups: [${rule.groups.map((group) => `"${group}"`).join(', ')}]`);
+        }
+        // identityClaim
+        if (rule.identityClaim) {
+            // does this need to be escaped?
+            ruleParts.push(`identityClaim: "${rule.identityClaim}"`);
+        }
+        // groupClaim
+        if (rule.groupClaim) {
+            // does this need to be escaped?
+            ruleParts.push(`groupClaim: "${rule.groupClaim}"`);
+        }
+        rules.push(`{${ruleParts.join(', ')}}`);
+    }
+    const authString = rules.length > 0 ? `@auth(rules: [${rules.join(',\n  ')}])` : '';
+    return { authString, authFields };
+}
+function capitalize(s) {
+    return `${s[0].toUpperCase()}${s.slice(1)}`;
+}
+function uncapitalize(s) {
+    return `${s[0].toLowerCase()}${s.slice(1)}`;
+}
+function fkName(model, field, identifier) {
+    return `${uncapitalize(model)}${capitalize(field)}${capitalize(identifier)}`;
+}
+/**
+ * Returns all explicitly defined and implied fields from a model.
+ *
+ * @param schema The schema the model is part of. Necessary to derive implied FK's.
+ * @param model The model to extract fields from and derive fields for.
+ * @returns
+ */
+const allImpliedFKs = (schema) => {
+    const fks = {};
+    function addFk({ onModel, asField, fieldDef, }) {
+        fks[onModel] = fks[onModel] || {};
+        fks[onModel][asField] = fieldDef;
+    }
+    // implied FK's
+    for (const [modelName, typeDef] of Object.entries(schema.data.types)) {
+        if (!isInternalModel(typeDef))
+            continue;
+        for (const [fieldName, fieldDef] of Object.entries(typeDef.data.fields)) {
+            if (!isModelField(fieldDef))
+                continue;
+            const relatedModel = schema.data.types[fieldDef.data.relatedModel];
+            switch (fieldDef.data.type) {
+                case ModelRelationalField_1.ModelRelationshipTypes.hasOne:
+                    for (const idField of relatedModel.data.identifier) {
+                        addFk({
+                            onModel: modelName,
+                            asField: fkName(modelName, fieldName, idField),
+                            fieldDef: {
+                                data: {
+                                    ...fieldDef.data,
+                                    fieldType: relatedModel.data.fields[idField]?.data.fieldType ||
+                                        ModelField_1.ModelFieldType.Id,
+                                },
+                            },
+                        });
+                    }
+                    break;
+                case ModelRelationalField_1.ModelRelationshipTypes.hasMany:
+                    {
+                        let authorization = [];
+                        let required = false;
+                        const [_belongsToName, belongsToDef] = Object.entries(relatedModel.data.fields).find(([_name, def]) => {
+                            return (isModelField(def) &&
+                                def.data.type === ModelRelationalField_1.ModelRelationshipTypes.belongsTo &&
+                                def.data.relatedModel === fieldName);
+                        }) || [];
+                        if (belongsToDef && isModelField(belongsToDef)) {
+                            authorization = belongsToDef.data.authorization;
+                            required = belongsToDef.data.valueRequired;
+                        }
+                        for (const idField of typeDef.data.identifier) {
+                            addFk({
+                                onModel: fieldDef.data.relatedModel,
+                                asField: fkName(modelName, fieldName, idField),
+                                fieldDef: {
+                                    data: {
+                                        ...(typeDef.data.fields[idField]?.data ||
+                                            (0, ModelField_1.id)().data),
+                                        authorization,
+                                        required,
+                                    },
+                                },
+                            });
+                        }
+                    }
+                    break;
+                case ModelRelationalField_1.ModelRelationshipTypes.belongsTo:
+                    {
+                        // only create if corresponds to hasOne
+                        const [_hasOneName, hasOneDef] = Object.entries(relatedModel.data.fields).find(([_name, def]) => {
+                            return (isModelField(def) &&
+                                def.data.type === ModelRelationalField_1.ModelRelationshipTypes.hasOne &&
+                                def.data.relatedModel === modelName);
+                        }) || [];
+                        if (hasOneDef && isModelField(hasOneDef)) {
+                            for (const idField of relatedModel.data.identifier) {
+                                addFk({
+                                    onModel: modelName,
+                                    asField: fkName(modelName, fieldName, idField),
+                                    fieldDef: {
+                                        data: {
+                                            ...typeDef.data,
+                                            fieldType: relatedModel.data.fields[idField]?.data.fieldType ||
+                                                ModelField_1.ModelFieldType.Id,
+                                        },
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    break;
+                case ModelRelationalField_1.ModelRelationshipTypes.manyToMany:
+                    // pretty sure there's nothing to do here.
+                    // the implicit join table already has everything, AFAIK.
+                    break;
+                default:
+                // nothing to do.
+            }
+        }
+    }
+    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)) {
+        const { authString, authFields: fieldAuthField } = calculateAuth(fieldDef?.data?.authorization || []);
+        if (authString)
+            fieldLevelAuthRules[fieldName] = authString;
+        if (fieldAuthField) {
+            Object.assign(authFields, fieldAuthField);
+        }
+    }
+    return fieldLevelAuthRules;
+}
+function processFields(fields, fieldLevelAuthRules, identifier, partitionKey) {
+    const gqlFields = [];
+    const models = [];
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const fieldAuth = fieldLevelAuthRules[fieldName]
+            ? ` ${fieldLevelAuthRules[fieldName]}`
+            : '';
+        if (isModelField(fieldDef)) {
+            gqlFields.push(`${fieldName}: ${modelFieldToGql(fieldDef.data)}${fieldAuth}`);
+        }
+        else if (isScalarField(fieldDef)) {
+            if (fieldName === partitionKey) {
+                gqlFields.push(`${fieldName}: ${scalarFieldToGql(fieldDef.data, identifier)}${fieldAuth}`);
+            }
+            else if (isRefField(fieldDef)) {
+                gqlFields.push(`${fieldName}: ${refFieldToGql(fieldDef.data)}${fieldAuth}`);
+            }
+            else if (isEnumType(fieldDef)) {
+                const enumName = capitalize(fieldName);
+                models.push([enumName, fieldDef]);
+                gqlFields.push(`${fieldName}: ${enumName}`);
+            }
+            else if (isCustomType(fieldDef)) {
+                const customTypeName = capitalize(fieldName);
+                models.push([customTypeName, fieldDef]);
+                gqlFields.push(`${fieldName}: ${customTypeName}`);
+            }
+            else {
+                gqlFields.push(`${fieldName}: ${scalarFieldToGql(fieldDef.data)}${fieldAuth}`);
+            }
+        }
+        else {
+            throw new Error(`Unexpected field definition: ${fieldDef}`);
+        }
+    }
+    return { gqlFields, models };
+}
+const schemaPreprocessor = (schema) => {
+    const gqlModels = [];
+    const fkFields = allImpliedFKs(schema);
+    const topLevelTypes = Object.entries(schema.data.types);
+    for (const [typeName, typeDef] of topLevelTypes) {
+        if (!isInternalModel(typeDef)) {
+            if (isEnumType(typeDef)) {
+                const enumType = `enum ${typeName} {\n${typeDef.values.join('\n')}\n}`;
+                gqlModels.push(enumType);
+            }
+            else if (isCustomType(typeDef)) {
+                const fields = typeDef.data.fields;
+                const authString = '';
+                const authFields = {};
+                const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
+                const { gqlFields, models } = processFields(fields, fieldLevelAuthRules);
+                topLevelTypes.push(...models);
+                const joined = gqlFields.join('\n  ');
+                const model = `type ${typeName} ${authString}\n{\n  ${joined}\n}`;
+                gqlModels.push(model);
+            }
+        }
+        else {
+            const fields = {
+                ...typeDef.data.fields,
+                ...fkFields[typeName],
+            };
+            const identifier = typeDef.data.identifier;
+            const [partitionKey] = identifier;
+            const { authString, authFields } = calculateAuth(typeDef.data.authorization);
+            const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
+            const { gqlFields, models } = processFields({
+                // idFields first, so they can be overridden by customer definitions when present.
+                ...idFields(typeDef),
+                ...fields,
+                ...authFields,
+                ...implicitTimestampFields(typeDef),
+            }, fieldLevelAuthRules, identifier, partitionKey);
+            topLevelTypes.push(...models);
+            const joined = gqlFields.join('\n  ');
+            const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;
+            gqlModels.push(model);
+        }
+    }
+    const processedSchema = gqlModels.join('\n\n');
+    return processedSchema;
+};
+/**
+ * Returns API definition from ModelSchema or string schema
+ * @param arg - { schema }
+ * @returns DerivedApiDefinition that conforms to IAmplifyGraphqlDefinition
+ */
+function processSchema(arg) {
+    const schema = schemaPreprocessor(arg.schema);
+    return { schema, functionSlots: [] };
+}
+exports.processSchema = processSchema;

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

@@ -0,0 +1,9 @@
+import { schema } from './ModelSchema';
+import { model } from './ModelType';
+import { id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress } from './ModelField';
+import { ref } from './RefType';
+import { hasOne, hasMany, belongsTo, manyToMany } from './ModelRelationalField';
+import { allow } from './Authorization';
+import { customType } from './CustomType';
+import { enumType } from './EnumType';
+export { schema, model, ref, customType, enumType as enum, hasOne, hasMany, belongsTo, manyToMany, allow, id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress, };

package/lib-esm/src/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipAddress = exports.url = exports.phone = exports.json = exports.email = exports.timestamp = exports.datetime = exports.time = exports.date = exports.boolean = exports.float = exports.integer = exports.string = exports.id = exports.allow = exports.manyToMany = exports.belongsTo = exports.hasMany = exports.hasOne = exports.enum = exports.customType = exports.ref = exports.model = exports.schema = void 0;
+const ModelSchema_1 = require("./ModelSchema");
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return ModelSchema_1.schema; } });
+const ModelType_1 = require("./ModelType");
+Object.defineProperty(exports, "model", { enumerable: true, get: function () { return ModelType_1.model; } });
+const ModelField_1 = require("./ModelField");
+Object.defineProperty(exports, "id", { enumerable: true, get: function () { return ModelField_1.id; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return ModelField_1.string; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return ModelField_1.integer; } });
+Object.defineProperty(exports, "float", { enumerable: true, get: function () { return ModelField_1.float; } });
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return ModelField_1.boolean; } });
+Object.defineProperty(exports, "date", { enumerable: true, get: function () { return ModelField_1.date; } });
+Object.defineProperty(exports, "time", { enumerable: true, get: function () { return ModelField_1.time; } });
+Object.defineProperty(exports, "datetime", { enumerable: true, get: function () { return ModelField_1.datetime; } });
+Object.defineProperty(exports, "timestamp", { enumerable: true, get: function () { return ModelField_1.timestamp; } });
+Object.defineProperty(exports, "email", { enumerable: true, get: function () { return ModelField_1.email; } });
+Object.defineProperty(exports, "json", { enumerable: true, get: function () { return ModelField_1.json; } });
+Object.defineProperty(exports, "phone", { enumerable: true, get: function () { return ModelField_1.phone; } });
+Object.defineProperty(exports, "url", { enumerable: true, get: function () { return ModelField_1.url; } });
+Object.defineProperty(exports, "ipAddress", { enumerable: true, get: function () { return ModelField_1.ipAddress; } });
+const RefType_1 = require("./RefType");
+Object.defineProperty(exports, "ref", { enumerable: true, get: function () { return RefType_1.ref; } });
+const ModelRelationalField_1 = require("./ModelRelationalField");
+Object.defineProperty(exports, "hasOne", { enumerable: true, get: function () { return ModelRelationalField_1.hasOne; } });
+Object.defineProperty(exports, "hasMany", { enumerable: true, get: function () { return ModelRelationalField_1.hasMany; } });
+Object.defineProperty(exports, "belongsTo", { enumerable: true, get: function () { return ModelRelationalField_1.belongsTo; } });
+Object.defineProperty(exports, "manyToMany", { enumerable: true, get: function () { return ModelRelationalField_1.manyToMany; } });
+const Authorization_1 = require("./Authorization");
+Object.defineProperty(exports, "allow", { enumerable: true, get: function () { return Authorization_1.allow; } });
+const CustomType_1 = require("./CustomType");
+Object.defineProperty(exports, "customType", { enumerable: true, get: function () { return CustomType_1.customType; } });
+const EnumType_1 = require("./EnumType");
+Object.defineProperty(exports, "enum", { enumerable: true, get: function () { return EnumType_1.enumType; } });

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

@@ -0,0 +1,18 @@
+/**
+ * references IAmplifyGraphqlDefinition from:
+ * https://github.com/aws-amplify/amplify-category-api/blob/4c0ea253a0bae51f775383929ba4748593185bc1/packages/amplify-graphql-api-construct/src/types.ts#L491-L503
+ *
+ * function slots is any'd for now. Will add actual type when we add support for this feature
+ */
+export interface DerivedApiDefinition {
+    /**
+     * Return the schema definition as a graphql string, with amplify directives allowed.
+     * @returns the rendered schema.
+     */
+    readonly schema: string;
+    /**
+     * Retrieve any function slots defined explicitly in the Api definition.
+     * @returns generated function slots
+     */
+    readonly functionSlots: any[];
+}

package/lib-esm/src/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * references IAmplifyGraphqlDefinition from:
+ * https://github.com/aws-amplify/amplify-category-api/blob/4c0ea253a0bae51f775383929ba4748593185bc1/packages/amplify-graphql-api-construct/src/types.ts#L491-L503
+ *
+ * function slots is any'd for now. Will add actual type when we add support for this feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });