@graphql-codegen/flutter-freezed 2.11.2-alpha-20221101110911-a036e7a25 → 3.0.0

package/esm/config/plugin-config.js

@@ -0,0 +1,137 @@
+export const APPLIES_ON_ENUM = ['enum'];
+export const APPLIES_ON_ENUM_VALUE = ['enum_value'];
+export const APPLIES_ON_CLASS = ['class'];
+export const APPLIES_ON_DEFAULT_FACTORY = ['factory', 'default_factory'];
+export const APPLIES_ON_UNION_FACTORY = ['factory', 'named_factory', 'union_factory'];
+export const APPLIES_ON_MERGED_FACTORY = ['factory', 'named_factory', 'merged_factory'];
+export const APPLIES_ON_FACTORY = ['factory', 'default_factory', 'named_factory', 'merged_factory', 'union_factory'];
+export const APPLIES_ON_DEFAULT_FACTORY_PARAMETERS = ['parameter', 'default_factory_parameter'];
+export const APPLIES_ON_UNION_FACTORY_PARAMETERS = [
+    'parameter',
+    'named_factory_parameter',
+    'union_factory_parameter',
+];
+export const APPLIES_ON_MERGED_FACTORY_PARAMETERS = [
+    'parameter',
+    'named_factory_parameter',
+    'merged_factory_parameter',
+];
+export const APPLIES_ON_PARAMETERS = [
+    'parameter',
+    'default_factory_parameter',
+    'named_factory_parameter',
+    'union_factory_parameter',
+    'merged_factory_parameter',
+];
+/**
+ * maps GraphQL scalar types to Dart's scalar types
+ */
+export const DART_SCALARS = {
+    ID: 'String',
+    String: 'String',
+    Boolean: 'bool',
+    Int: 'int',
+    Float: 'double',
+    DateTime: 'DateTime',
+};
+export const DART_KEYWORDS = {
+    abstract: 'built-in',
+    else: 'reserved',
+    import: 'built-in',
+    show: 'context',
+    as: 'built-in',
+    enum: 'reserved',
+    in: 'reserved',
+    static: 'built-in',
+    assert: 'reserved',
+    export: 'built-in',
+    interface: 'built-in',
+    super: 'reserved',
+    async: 'context',
+    extends: 'reserved',
+    is: 'reserved',
+    switch: 'reserved',
+    await: 'async-reserved',
+    extension: 'built-in',
+    late: 'built-in',
+    sync: 'context',
+    break: 'reserved',
+    external: 'built-in',
+    library: 'built-in',
+    this: 'reserved',
+    case: 'reserved',
+    factory: 'built-in',
+    mixin: 'built-in',
+    throw: 'reserved',
+    catch: 'reserved',
+    false: 'reserved',
+    new: 'reserved',
+    true: 'reserved',
+    class: 'reserved',
+    final: 'reserved',
+    null: 'reserved',
+    try: 'reserved',
+    const: 'reserved',
+    finally: 'reserved',
+    on: 'context',
+    typedef: 'built-in',
+    continue: 'reserved',
+    for: 'reserved',
+    operator: 'built-in',
+    var: 'reserved',
+    covariant: 'built-in',
+    Function: 'built-in',
+    part: 'built-in',
+    void: 'reserved',
+    default: 'reserved',
+    get: 'built-in',
+    required: 'built-in',
+    while: 'reserved',
+    deferred: 'built-in',
+    hide: 'context',
+    rethrow: 'reserved',
+    with: 'reserved',
+    do: 'reserved',
+    if: 'reserved',
+    return: 'reserved',
+    yield: 'async-reserved',
+    dynamic: 'built-in',
+    implements: 'built-in',
+    set: 'built-in',
+    // built-in types
+    int: 'reserved',
+    double: 'reserved',
+    String: 'reserved',
+    bool: 'reserved',
+    List: 'reserved',
+    Set: 'reserved',
+    Map: 'reserved',
+    Runes: 'reserved',
+    Symbol: 'reserved',
+    Object: 'reserved',
+    Null: 'reserved',
+    Never: 'reserved',
+    Enum: 'reserved',
+    Future: 'reserved',
+    Iterable: 'reserved',
+};
+/** initializes a FreezedPluginConfig with the defaults values */
+export const defaultFreezedPluginConfig = {
+    camelCasedEnums: true,
+    copyWith: undefined,
+    customScalars: {},
+    defaultValues: undefined,
+    deprecated: undefined,
+    equal: undefined,
+    escapeDartKeywords: true,
+    final: undefined,
+    // fromJsonToJson: true, // TODO: @next-version
+    ignoreTypes: undefined,
+    immutable: true,
+    makeCollectionsUnmodifiable: undefined,
+    mergeTypes: undefined,
+    mutableInputs: true,
+    privateEmptyConstructor: true,
+    unionClass: undefined,
+};
+//#endregion

package/esm/freezed-declaration-blocks/class-block.js

@@ -1,228 +1,91 @@
 import { indent } from '@graphql-codegen/visitor-plugin-common';
 import { Kind } from 'graphql';
-import { camelCase, pascalCase } from 'change-case-all';
-import { getCustomDecorators, transformCustomDecorators, FreezedConfigValue, } from '../utils.js';
-import { FreezedFactoryBlock } from './factory-block.js';
-export class FreezedDeclarationBlock {
-    constructor(_config, _freezedFactoryBlockRepository, _node) {
-        this._config = _config;
-        this._freezedFactoryBlockRepository = _freezedFactoryBlockRepository;
-        this._node = _node;
-        /** document the class  */
-        this._comment = '';
-        /** a list of decorators to copy paste to the generator */
-        this._decorators = [];
-        /** a list of default constructor and named Constructors used create a Freezed union/sealed class */
-        this._factoryBlocks = [];
-        this._config = _config;
-        this._freezedFactoryBlockRepository = _freezedFactoryBlockRepository;
-        this._node = _node;
-        this._freezedConfigValue = new FreezedConfigValue(this._config, this._node.name.value);
-    }
-    init() {
-        if (this._node.kind === Kind.ENUM_TYPE_DEFINITION) {
-            this.setDecorators().setName().setShape().setBlock();
-            return this;
-        }
-        this.setComment().setDecorators().setName().setFactoryBlocks().setShape().setBlock();
-        return this;
-    }
-    setComment() {
-        var _a;
-        const comment = (_a = this._node.description) === null || _a === void 0 ? void 0 : _a.value;
-        if (comment && comment !== null && comment !== '') {
-            this._comment = `/// ${comment} \n`;
-        }
-        return this;
-    }
-    getEnumComment(value) {
-        var _a;
-        const comment = (_a = value.description) === null || _a === void 0 ? void 0 : _a.value;
-        if (comment && comment !== null && comment !== '') {
-            return `/// ${comment} \n`;
-        }
-        return '';
-    }
-    setDecorators() {
-        var _a, _b;
-        const name = this._node.name.value;
-        // determine if should mark as deprecated
-        const isDeprecated = (_b = (_a = this._config.typeSpecificFreezedConfig) === null || _a === void 0 ? void 0 : _a[name]) === null || _b === void 0 ? void 0 : _b.deprecated;
-        this._decorators =
-            this._node.kind === Kind.ENUM_TYPE_DEFINITION
-                ? [...transformCustomDecorators(getCustomDecorators(this._config, ['enum'], name), this._node)]
-                : [
-                    this.getFreezedDecorator(),
-                    ...transformCustomDecorators(getCustomDecorators(this._config, ['class'], name), this._node),
-                ];
-        // @deprecated
-        // if this._decorators doesn't include an @deprecated decorator but the field is marked as @deprecated...
-        if (!this._decorators.includes('@deprecated') && isDeprecated) {
-            this._decorators = [...this._decorators, '@deprecated\n'];
-        }
-        return this;
-    }
-    getFreezedDecorator() {
-        const use_unfreezed = () => {
-            if (!this._freezedConfigValue.get('immutable') ||
-                (this._node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && this._freezedConfigValue.get('mutableInputs'))) {
-                return '@unfreezed\n';
-            }
-            return use_Freezed_or_freezed();
-        };
-        const use_Freezed_or_freezed = () => {
-            if (isCustomizedFreezed()) {
-                const copyWith = this._freezedConfigValue.get('copyWith');
-                const equal = this._freezedConfigValue.get('equal');
-                const makeCollectionsUnmodifiable = this._freezedConfigValue.get('makeCollectionsUnmodifiable');
-                const unionKey = this._freezedConfigValue.get('unionKey');
-                const unionValueCase = this._freezedConfigValue.get('unionValueCase');
-                let atFreezed = '@Freezed(\n';
-                if (copyWith !== undefined) {
-                    atFreezed += indent(`copyWith: ${copyWith},\n`);
-                }
-                if (equal !== undefined) {
-                    atFreezed += indent(`equal: ${equal},\n`);
-                }
-                if (makeCollectionsUnmodifiable !== undefined) {
-                    atFreezed += indent(`makeCollectionsUnmodifiable: ${makeCollectionsUnmodifiable},\n`);
-                }
-                if (unionKey !== undefined) {
-                    atFreezed += indent(`unionKey: ${unionKey},\n`);
-                }
-                if (unionValueCase !== undefined) {
-                    atFreezed += indent(`unionValueCase: '${unionValueCase}',\n`);
-                }
-                atFreezed += ')\n';
-                return atFreezed;
-            }
-            // else fallback to the normal @freezed decorator
-            return '@freezed\n';
-        };
-        const isCustomizedFreezed = () => {
-            return (this._freezedConfigValue.get('copyWith') !== undefined ||
-                this._freezedConfigValue.get('equal') !== undefined ||
-                this._freezedConfigValue.get('makeCollectionsUnmodifiable') !== undefined ||
-                this._freezedConfigValue.get('unionKey') !== undefined ||
-                this._freezedConfigValue.get('unionValueCase') !==
-                    undefined);
-        };
-        // this is the start of the pipeline of decisions to determine which Freezed decorator to use
-        return use_unfreezed();
-    }
-    setName() {
-        this._name = pascalCase(this._node.name.value);
-        return this;
-    }
-    setFactoryBlocks() {
-        var _a, _b, _c, _d;
-        if (this._node.kind === Kind.UNION_TYPE_DEFINITION) {
-            this._factoryBlocks =
-                (_b = (_a = this._node.types) === null || _a === void 0 ? void 0 : _a.map((_type) => new FreezedFactoryBlock(this._config, this._node).init())) !== null && _b !== void 0 ? _b : [];
-        }
-        else if (this._node.kind !== Kind.ENUM_TYPE_DEFINITION) {
-            /*
-              for `ObjectTypeDefinitionNode` and `InputObjectTypeDefinitionNode` nodes,
-              we use the `ShapeRepository`
-              to register the `FreezedFactoryBlock` so that we can use it later
-              when we are merging inputs or generating freezed union/sealed classes
-              for GraphQL union types
-            */
-            this._factoryBlocks =
-                (_d = (_c = this._node.fields) === null || _c === void 0 ? void 0 : _c.map((_field) => this._freezedFactoryBlockRepository.register(this._node.name.value, new FreezedFactoryBlock(this._config, this._node).init()))) !== null && _d !== void 0 ? _d : [];
-        }
-        return this;
-    }
-    setShape() {
-        var _a, _b, _c;
-        let shape = '';
-        // some helper variables
-        const name = this._node.name.value;
-        let namedConstructor;
-        let factoryBlockKey;
-        // handle enums differently
-        if (this._node.kind === Kind.ENUM_TYPE_DEFINITION) {
-            this._shape = (_a = this._node.values) === null || _a === void 0 ? void 0 : _a.map((value) => {
-                var _a;
-                shape = indent(this.getEnumComment(value));
-                if ((_a = this._config.camelCasedEnums) !== null && _a !== void 0 ? _a : true) {
-                    shape += `@JsonKey(name: ${value.name.value}) ${value.name.value.toLowerCase()}`;
-                }
-                else {
-                    shape += value.name.value;
-                }
-                return `${shape}\n`;
-            }).join('');
-            return this;
-        }
-        // append private empty constructor
-        if (this._freezedConfigValue.get('privateEmptyConstructor')) {
-            shape += indent(`const ${this._name}._();\n\n`);
-        }
-        // decide whether to append an empty Union constructor
-        if (this._freezedConfigValue.get('defaultUnionConstructor') && this._node.kind === Kind.UNION_TYPE_DEFINITION) {
-            shape += indent(`const factory ${this._name}() = _${this._name};\n\n`);
-        }
-        // append tokens which will be used to retrieve the factory blocks
-        // from the FreezedFactoryBlockRepository
-        if (this._node.kind === Kind.UNION_TYPE_DEFINITION) {
-            (_c = (_b = this._node) === null || _b === void 0 ? void 0 : _b.types) === null || _c === void 0 ? void 0 : _c.forEach(type => {
-                namedConstructor = type.name.value;
-                factoryBlockKey = namedConstructor;
-                shape += `==>factory==>${factoryBlockKey}==>${'union_factory'}==>${name}==>${namedConstructor}\n`;
-            });
-        }
-        else {
-            factoryBlockKey = name;
-            // replace token for the ObjectType & InputType to be replaced with the default Freezed constructor
-            shape += `==>factory==>${factoryBlockKey}==>${'class_factory'}==>${name}\n`;
-            const mergeInputs = this._freezedConfigValue.get('mergeInputs');
-            if (this._node.kind === Kind.OBJECT_TYPE_DEFINITION && mergeInputs) {
-                // replace token for the InputTypes(a.k.a namedConstructors) as a union/sealed class
-                mergeInputs.forEach(input => {
-                    const separator = input.includes('$') ? '$' : input.includes(name) ? name : '*';
-                    namedConstructor = camelCase(input.split(separator).join('_'));
-                    factoryBlockKey = input.replace('$', name);
-                    shape += `==>factory==>${factoryBlockKey}==>${'merged_input_factory'}==>${name}==>${namedConstructor}\n`;
-                });
-            }
-        }
-        this._shape = shape;
-        return this;
-    }
-    /**
-     * returns the string output of the block
-     */
-    setBlock() {
+import { Config } from '../config/config-value.js';
+import { APPLIES_ON_CLASS } from '../config/plugin-config.js';
+import { FactoryBlock } from './factory-block.js';
+import { TypeName } from '../config/pattern.js';
+import { Block } from './index.js';
+import { nodeIsObjectType, stringIsNotEmpty } from '../utils.js';
+export class ClassBlock {
+    static build(config, node) {
+        const typeName = TypeName.fromString(node.name.value);
+        const _className = Block.buildBlockName(config, APPLIES_ON_CLASS, typeName.value, typeName, undefined, 'PascalCase');
         let block = '';
-        //append comment
-        block += this._comment;
-        // append the decorators
-        block += this._decorators.join('');
-        // handle enums differently
-        if (this._node.kind === Kind.ENUM_TYPE_DEFINITION) {
-            block += `enum ${this._name}{\n${this._shape}}\n\n`;
-            this._block = block;
-            return this;
-        }
-        // append start of class definition
-        block += `class ${this._name} with _$${this._name} {\n`;
-        // append the shape
-        block += this._shape;
-        // append fromJson
-        if (this._freezedConfigValue.get('fromJsonToJson')) {
-            block += indent(`factory ${this._name}.fromJson(Map<String, Object?> json) => _${this._name}FromJson(json);\n`);
-        }
-        //append end of class definition
-        block += '}\n\n';
-        this._block = block;
-        return this;
-    }
-    /** returns the block */
-    toString() {
-        if (!this._block) {
-            throw new Error('setShape must be called before calling toString()');
-        }
-        return this._block;
+        // the comments should be  on the factory block instead
+        // block += Block.buildComment(node);
+        block += this.buildDecorators(config, node);
+        block += this.buildHeader(config, typeName, _className);
+        block += this.buildBody(config, node);
+        block += this.buildFooter(config, typeName, _className);
+        return block;
     }
 }
+ClassBlock.buildDecorators = (config, node) => {
+    const freezedDecorator = ClassBlock.buildFreezedDecorator(config, node);
+    // TODO: consider implementing custom decorators
+    return [freezedDecorator].join('');
+};
+ClassBlock.buildFreezedDecorator = (config, node) => {
+    // this is the start of the pipeline of decisions to determine which Freezed decorator to use
+    return ClassBlock.decorateAsFreezed(config, node);
+};
+ClassBlock.decorateAsFreezed = (config, node) => {
+    const typeName = TypeName.fromString(node.name.value);
+    const copyWith = Config.copyWith(config, typeName);
+    const equal = Config.equal(config, typeName);
+    const makeCollectionsUnmodifiable = Config.makeCollectionsUnmodifiable(config, typeName);
+    const unionKey = Config.unionKey();
+    const unionValueCase = Config.unionValueCase();
+    const body = [
+        copyWith !== undefined ? `copyWith: ${copyWith},\n` : undefined,
+        equal !== undefined ? `equal: ${equal},\n` : undefined,
+        makeCollectionsUnmodifiable !== undefined
+            ? `makeCollectionsUnmodifiable: ${makeCollectionsUnmodifiable},\n`
+            : undefined,
+        unionKey !== undefined ? `unionKey: ${unionKey},\n` : undefined,
+        unionValueCase !== undefined ? `unionValueCase: '${unionValueCase}',\n` : undefined,
+    ]
+        .filter(value => value !== undefined)
+        .map(value => indent(value))
+        .join('');
+    return stringIsNotEmpty(body) ? `@Freezed(\n${body})\n` : ClassBlock.decorateAsUnfreezed(config, node);
+};
+ClassBlock.decorateAsUnfreezed = (config, node) => {
+    const typeName = TypeName.fromString(node.name.value);
+    const immutable = Config.immutable(config, typeName);
+    const mutableInputs = Config.mutableInputs(config, typeName);
+    const mutable = immutable !== true || (node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && mutableInputs);
+    return mutable ? '@unfreezed\n' : '@freezed\n';
+};
+ClassBlock.buildHeader = (config, typeName, _className) => {
+    const privateEmptyConstructor = Config.privateEmptyConstructor(config, typeName)
+        ? indent(`const ${_className}._();\n\n`)
+        : '';
+    return `class ${_className} with _$${_className} {\n${privateEmptyConstructor}`;
+};
+ClassBlock.buildBody = (config, node) => {
+    var _a;
+    const className = TypeName.fromString(node.name.value);
+    let body = '';
+    if (nodeIsObjectType(node)) {
+        body += FactoryBlock.serializeDefaultFactory(className);
+    }
+    else if (node.kind === Kind.UNION_TYPE_DEFINITION) {
+        body += ((_a = node.types) !== null && _a !== void 0 ? _a : [])
+            .map(value => {
+            const factoryName = TypeName.fromString(value.name.value);
+            return FactoryBlock.serializeUnionFactory(className, factoryName);
+        })
+            .join('');
+    }
+    body += Config.mergeTypes(config, className)
+        .map(value => {
+        const factoryName = TypeName.fromString(value);
+        return FactoryBlock.serializeMergedFactory(className, factoryName);
+    })
+        .join('');
+    return body;
+};
+ClassBlock.buildFooter = (config, typeName, _className) => {
+    return indent(`factory ${_className}.fromJson(Map<String, dynamic> json) => _$${_className}FromJson(json);\n}\n\n`);
+};

package/esm/freezed-declaration-blocks/enum-block.js

@@ -0,0 +1,50 @@
+import { TypeName, FieldName } from '../config/pattern.js';
+import { APPLIES_ON_ENUM, APPLIES_ON_ENUM_VALUE } from '../config/plugin-config.js';
+import { indent } from '@graphql-codegen/visitor-plugin-common';
+import { Block } from './index.js';
+import { Config } from '../config/config-value.js';
+import { atJsonKeyDecorator, stringIsNotEmpty } from '../utils.js';
+export class EnumBlock {
+    // TODO: @next-version: Implement enhanced enums
+    static build(config, node) {
+        const typeName = TypeName.fromString(node.name.value);
+        let block = '';
+        block += Block.buildComment(node);
+        block += this.buildDecorators();
+        block += this.buildHeader(config, typeName);
+        block += this.buildBody(config, node);
+        block += this.buildFooter();
+        return block;
+    }
+}
+EnumBlock.buildDecorators = () => {
+    // TODO: @next-version: @JsonEnum(valueField: 'code', fieldRename: 'new-name')
+    return '';
+};
+EnumBlock.buildHeader = (config, typeName) => {
+    const enumTypeName = Block.buildBlockName(config, APPLIES_ON_ENUM, typeName.value, typeName, undefined, 'PascalCase');
+    return `enum ${enumTypeName} {\n`;
+};
+EnumBlock.buildBody = (config, node) => {
+    var _a, _b;
+    const typeName = TypeName.fromString(node.name.value);
+    return (_b = ((_a = node.values) !== null && _a !== void 0 ? _a : [])) === null || _b === void 0 ? void 0 : _b.map((enumValue) => {
+        const fieldName = FieldName.fromString(enumValue.name.value);
+        const enumValueName = Block.buildBlockName(config, APPLIES_ON_ENUM_VALUE, fieldName.value, typeName, fieldName, Config.camelCasedEnums(config));
+        const comment = Block.buildComment(enumValue);
+        const jsonKey = atJsonKeyDecorator({
+            name: fieldName.value !== enumValueName ? fieldName.value : undefined,
+        });
+        //TODO: @next-version: const jsonValue = @JsonValue(String|int)
+        const decorators = [
+            jsonKey,
+            // jsonValue
+        ].join('');
+        return [comment, decorators, `${enumValueName}\n`]
+            .map(block => (stringIsNotEmpty(block) ? indent(block) : block))
+            .join('');
+    }).join('');
+};
+EnumBlock.buildFooter = () => {
+    return '}\n\n';
+};