@graphql-codegen/flutter-freezed 2.11.2 → 3.0.1-alpha-20230130180936-04996f117

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

@@ -1,121 +1,89 @@
 import { indent } from '@graphql-codegen/visitor-plugin-common';
-import { Kind } from 'graphql';
-import { camelCase, pascalCase } from 'change-case-all';
-import { FreezedParameterBlock } from './parameter-block.js';
-import { FreezedConfigValue, getCustomDecorators, transformCustomDecorators } from '../utils.js';
-export class FreezedFactoryBlock {
-    constructor(_config, _node) {
-        this._config = _config;
-        this._node = _node;
-        /** document the constructor */
-        this._comment = '';
-        /** a list of decorators to copy paste to the generator */
-        this._decorators = [];
-        /** a list of interfaces to implements */
-        // _implements: string[] = [];
-        /** a list of class to mixin with */
-        // _mixins: string[] = [];
-        /** the parameters of this factory constructor */
-        // TODO: handle other parameter types like positional parameters later.
-        // TODO: sticking to named parameters because GraphQL is a typed language
-        this._parameters = [];
-        this._config = _config;
-        this._node = _node;
-        this._freezedConfigValue = new FreezedConfigValue(_config, _node.name.value);
-    }
-    init() {
-        /*
-          setDecorators(), setName() and setType() will be called
-          when the factory is retrieved from the repository
-        */
-        this.setComment().setParameters().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 = indent(`/// ${comment} \n`);
-        }
-        return this;
-    }
-    setDecorators(appliesOn, nodeName) {
-        this._decorators = [
-            ...transformCustomDecorators(getCustomDecorators(this._config, appliesOn.split(','), nodeName), this._node),
-        ];
-        return this;
-    }
-    setKey(key) {
-        this._key = pascalCase(key);
-        return this;
+import { Config } from '../config/config-value.js';
+import { TypeName } from '../config/pattern.js';
+import { APPLIES_ON_DEFAULT_FACTORY, APPLIES_ON_UNION_FACTORY, APPLIES_ON_MERGED_FACTORY, APPLIES_ON_DEFAULT_FACTORY_PARAMETERS, APPLIES_ON_UNION_FACTORY_PARAMETERS, APPLIES_ON_MERGED_FACTORY_PARAMETERS, } from '../config/plugin-config.js';
+import { Block } from './index.js';
+import { ParameterBlock } from './parameter-block.js';
+import { stringIsNotEmpty } from '../utils.js';
+export class FactoryBlock {
+    static build(config, node, blockAppliesOn, className, factoryName) {
+        let block = '';
+        block += Block.buildComment(node);
+        block += this.buildDecorators(config, blockAppliesOn, className, factoryName);
+        block += this.buildHeader(config, blockAppliesOn, className, factoryName);
+        block += this.buildBody(config, node, blockAppliesOn);
+        factoryName = blockAppliesOn.includes('default_factory') ? className : factoryName;
+        block += this.buildFooter(config, blockAppliesOn, factoryName);
+        return block;
     }
-    setName(name) {
-        this._name = pascalCase(name);
-        return this;
+}
+FactoryBlock.buildDecorators = (config, blockAppliesOn, className, factoryName) => {
+    // TODO: @Assert
+    const typeName = factoryName ? TypeName.fromUnionOfTypeNames(className, factoryName) : className;
+    const deprecatedDecorator = Config.deprecated(config, blockAppliesOn, typeName);
+    const decorators = [deprecatedDecorator].join('');
+    return stringIsNotEmpty(decorators) ? indent(decorators) : decorators;
+};
+FactoryBlock.buildHeader = (config, blockAppliesOn, className, factoryName) => {
+    const typeName = factoryName ? TypeName.fromUnionOfTypeNames(className, factoryName) : className;
+    const immutable = Config.immutable(config, typeName);
+    // const mutableInputs = Config.mutableInputs(config, factoryName);
+    // const mutable = immutable !== true || (node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && mutableInputs);
+    const constFactory = immutable ? indent('const factory') : indent('factory');
+    const _className = Block.buildBlockName(config, blockAppliesOn, className.value, className, undefined, 'PascalCase');
+    if (factoryName) {
+        const _factoryName = Block.buildBlockName(config, blockAppliesOn, factoryName.value, factoryName, undefined, 'camelCase');
+        return `${constFactory} ${_className}.${_factoryName}({\n`;
     }
-    setNamedConstructor(namedConstructor) {
-        if (namedConstructor) {
-            this._namedConstructor = camelCase(namedConstructor);
-        }
-        return this;
+    return `${constFactory} ${_className}({\n`;
+};
+FactoryBlock.buildBody = (config, node, appliesOn) => {
+    var _a, _b;
+    let appliesOnParameters = [];
+    if (appliesOn.includes('default_factory')) {
+        appliesOnParameters = APPLIES_ON_DEFAULT_FACTORY_PARAMETERS;
     }
-    setParameters() {
-        var _a, _b, _c;
-        // TODO: get this from config directly
-        const mergeInputs = this._freezedConfigValue.get('mergeInputs');
-        const appliesOn = this._namedConstructor
-            ? ['union_factory_parameter']
-            : (mergeInputs !== null && mergeInputs !== void 0 ? mergeInputs : mergeInputs !== [])
-                ? ['merged_input_parameter']
-                : ['class_factory_parameter'];
-        if (this._node.kind !== Kind.UNION_TYPE_DEFINITION && this._node.kind !== Kind.ENUM_TYPE_DEFINITION) {
-            this._parameters =
-                (_c = (_b = (_a = this._node) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.map((field) => new FreezedParameterBlock(this._config, appliesOn, this._node, field).init())) !== null && _c !== void 0 ? _c : [];
-        }
-        return this;
+    else if (appliesOn.includes('union_factory')) {
+        appliesOnParameters = APPLIES_ON_UNION_FACTORY_PARAMETERS;
     }
-    setShape() {
-        this._shape = this._parameters.map(p => p.toString()).join('');
-        return this;
+    else if (appliesOn.includes('merged_factory')) {
+        appliesOnParameters = APPLIES_ON_MERGED_FACTORY_PARAMETERS;
     }
-    setBlock() {
-        let block = '';
-        //append comment
-        block += this._comment;
-        // append the decorators
-        block += this._decorators.map(d => indent(d)).join('');
-        block += indent('');
-        // decide if to use const or not
-        if (this._freezedConfigValue.get('immutable')) {
-            block += 'const ';
-        }
-        // append the factory keyword and the name
-        block += `factory ${this._name}`;
-        // append .namedConstructor is not null
-        if (this._namedConstructor && this._namedConstructor !== '') {
-            block += `.${this._namedConstructor}`;
-        }
-        // append the parenthesis for the constructor and braces for the named parameters
-        block += '({\n';
-        //append the shape
-        block += this._shape;
-        // close the constructor and assign the key
-        block += indent(`}) = `);
-        // but first decide whether prefix the key with an underscore
-        if (!this._namedConstructor) {
-            block += '_';
-        }
-        // finally, append the key
-        block += `${this._key};\n`;
-        // store it in the shape
-        this._block = block;
-        return this;
+    return ((_b = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.map((field) => {
+        return ParameterBlock.build(config, node, field, appliesOnParameters);
+    }).join('')) !== null && _b !== void 0 ? _b : '');
+};
+FactoryBlock.buildFooter = (config, blockAppliesOn, factoryName) => {
+    const _ = blockAppliesOn.includes('default_factory') ? '_' : '';
+    const _factoryName = Block.buildBlockName(config, blockAppliesOn, factoryName.value, factoryName, undefined, 'PascalCase');
+    return indent(`}) = ${_}${_factoryName};\n\n`);
+};
+FactoryBlock.serializeDefaultFactory = (className) => {
+    return `${Block.tokens.defaultFactory}${className.value}==>${APPLIES_ON_DEFAULT_FACTORY.join(',')}\n`;
+};
+FactoryBlock.serializeUnionFactory = (className, factoryName) => {
+    return `${Block.tokens.unionFactory}${className.value}==>${factoryName.value}==>${APPLIES_ON_UNION_FACTORY.join(',')}\n`;
+};
+FactoryBlock.serializeMergedFactory = (className, factoryName) => {
+    return `${Block.tokens.mergedFactory}${className.value}==>${factoryName.value}==>${APPLIES_ON_MERGED_FACTORY.join(',')}\n`;
+};
+FactoryBlock.deserializeFactory = (config, nodeRepository, blockAppliesOn, className) => {
+    const node = nodeRepository.get(className.value);
+    if (node) {
+        return FactoryBlock.buildFromFactory(config, node, blockAppliesOn, className);
     }
-    /** returns the block */
-    toString() {
-        if (!this._block) {
-            throw new Error('FreezedFactoryBlock: setShape must be called before calling toString()');
-        }
-        return this._block;
+    return '';
+};
+FactoryBlock.deserializeNamedFactory = (config, nodeRepository, blockAppliesOn, className, factoryName) => {
+    const node = nodeRepository.get(factoryName.value);
+    if (node) {
+        return FactoryBlock.buildFromNamedFactory(config, node, blockAppliesOn, className, factoryName);
     }
-}
+    return '';
+};
+FactoryBlock.buildFromFactory = (config, node, blockAppliesOn, className) => {
+    return FactoryBlock.build(config, node, blockAppliesOn, className);
+};
+FactoryBlock.buildFromNamedFactory = (config, node, blockAppliesOn, className, factoryName) => {
+    return FactoryBlock.build(config, node, blockAppliesOn, className, factoryName);
+};

package/esm/freezed-declaration-blocks/index.js

@@ -1,3 +1,89 @@
-export * from './parameter-block.js';
-export * from './factory-block.js';
-export * from './class-block.js';
+import { snakeCase } from 'change-case-all';
+import { Kind } from 'graphql';
+import { TypeName } from '../config/pattern.js';
+import { Config } from '../config/config-value.js';
+import { dartCasing, escapeDartKeyword, isDartKeyword, nodeIsObjectType } from '../utils.js';
+import { ClassBlock } from './class-block.js';
+import { EnumBlock } from './enum-block.js';
+import { FactoryBlock } from './factory-block.js';
+export class Block {
+}
+Block.buildImportStatements = (fileName) => {
+    if (fileName.length < 1) {
+        throw new Error('fileName is required and must not be empty');
+    }
+    const segments = fileName.split('/');
+    const target = segments[segments.length - 1];
+    const expectedFileName = snakeCase(target.replace(/\.dart/g, ''));
+    return [
+        `import 'package:freezed_annotation/freezed_annotation.dart';\n`,
+        `import 'package:flutter/foundation.dart';\n\n`,
+        `part '${expectedFileName}.freezed.dart';\n`,
+        `part '${expectedFileName}.g.dart';\n\n`,
+    ].join('');
+};
+/**
+ * Transforms the AST nodes into  Freezed classes/models
+ * @param config The plugin configuration object
+ * @param node the AST node passed by the schema visitor
+ * @param nodeRepository A map that stores the name of the Graphql Type as the key and it AST node as the value. Used to build FactoryBlocks from placeholders for mergedInputs and Union Types
+ * @returns a string output of a `FreezedDeclarationBlock` which represents a Freezed class/model in Dart
+ */
+Block.build = (config, node, nodeRepository) => {
+    // ignore these...
+    const typeName = TypeName.fromString(node.name.value);
+    if (['Query', 'Mutation', 'Subscription', ...Config.ignoreTypes(config, typeName)].includes(typeName.value)) {
+        return '';
+    }
+    // registers all the ObjectTypes
+    if (nodeIsObjectType(node)) {
+        nodeRepository.register(node);
+    }
+    return node.kind === Kind.ENUM_TYPE_DEFINITION ? EnumBlock.build(config, node) : ClassBlock.build(config, node);
+};
+Block.buildComment = (node) => {
+    var _a;
+    const comment = (_a = node === null || node === void 0 ? void 0 : node.description) === null || _a === void 0 ? void 0 : _a.value;
+    return comment && (comment === null || comment === void 0 ? void 0 : comment.length) > 0
+        ? `${comment
+            .trim()
+            .split(/\n/gm)
+            .map(c => `/// ${c.trim().replace(/^#/, '')}\n`)
+            .join('')}`
+        : '';
+};
+Block.buildBlockName = (config, blockAppliesOn, identifier, typeName, fieldName, blockCasing) => {
+    identifier = dartCasing(identifier, blockCasing);
+    if (isDartKeyword(identifier)) {
+        return escapeDartKeyword(config, blockAppliesOn, identifier, typeName, fieldName);
+    }
+    return identifier;
+};
+Block.tokens = {
+    defaultFactory: '==>default_factory==>',
+    unionFactory: '==>union_factory==>',
+    mergedFactory: '==>merged_factory==>',
+    fromJsonToJson: '==>from_json_to_json==>',
+};
+Block.regexpForToken = (tokenName) => {
+    return RegExp(`${Block.tokens[tokenName]}.+\n`, 'gm');
+};
+Block.replaceTokens = (config, nodeRepository, generatedBlocks) => generatedBlocks
+    .map(block => {
+    block = Block.replaceDefaultFactoryToken(block, config, nodeRepository);
+    block = Block.replaceNamedFactoryToken(block, config, nodeRepository, 'unionFactory');
+    block = Block.replaceNamedFactoryToken(block, config, nodeRepository, 'mergedFactory');
+    // TODO: one more for parameter fromJson and toJson tokens inside @JsonKey
+    return block;
+})
+    .join('');
+Block.replaceDefaultFactoryToken = (block, config, nodeRepository) => block.replace(Block.regexpForToken('defaultFactory'), token => {
+    const pattern = token.replace(Block.tokens.defaultFactory, '').trim();
+    const [className, blockAppliesOn] = pattern.split('==>');
+    return FactoryBlock.deserializeFactory(config, nodeRepository, blockAppliesOn.split(','), TypeName.fromString(className));
+});
+Block.replaceNamedFactoryToken = (block, config, nodeRepository, blockType) => block.replace(Block.regexpForToken(blockType), token => {
+    const pattern = token.replace(Block.tokens[blockType], '').trim();
+    const [className, factoryName, blockAppliesOn] = pattern.split('==>');
+    return FactoryBlock.deserializeNamedFactory(config, nodeRepository, blockAppliesOn.split(','), TypeName.fromString(className), TypeName.fromString(factoryName));
+});

package/esm/freezed-declaration-blocks/node-repository.js

@@ -0,0 +1,22 @@
+//#region NodeRepository classes
+import { nodeIsObjectType } from '../utils.js';
+/**
+ * stores an instance of  `ObjectTypeDefinitionNode` or `InputObjectTypeDefinitionNode` using the node name as the key
+ * and returns that node when replacing placeholders
+ * */
+export class NodeRepository {
+    constructor() {
+        this._store = {};
+    }
+    get(key) {
+        return this._store[key];
+    }
+    register(node) {
+        if (!nodeIsObjectType(node)) {
+            throw new Error('Node is not an ObjectTypeDefinitionNode or InputObjectTypeDefinitionNode');
+        }
+        this._store[node.name.value] = node;
+        return node;
+    }
+}
+//#endregion

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

@@ -1,146 +1,58 @@
+var _a;
+import { atJsonKeyDecorator, stringIsNotEmpty } from '../utils.js';
+import { Config } from '../config/config-value.js';
+import { FieldName, TypeName } from '../config/pattern.js';
+import { Block } from './index.js';
 import { indent } from '@graphql-codegen/visitor-plugin-common';
-import { camelCase } from 'change-case-all';
-import { getCustomDecorators, transformCustomDecorators, FreezedConfigValue } from '../utils.js';
-/**
- * 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 class FreezedParameterBlock {
-    constructor(_config, _appliesOn, _node, _field) {
-        this._config = _config;
-        this._appliesOn = _appliesOn;
-        this._node = _node;
-        this._field = _field;
-        /** document the property */
-        this._comment = '';
-        /** a list of decorators to copy paste to the generator */
-        this._decorators = [];
-        this.propertyType = (field, type, parentType) => {
-            if (this.isNonNullType(type)) {
-                return this.propertyType(field, type.type, type);
-            }
-            if (this.isListType(type)) {
-                const T = this.propertyType(field, type.type, type);
-                return `List<${T}>${this.isNonNullType(parentType) ? '' : '?'}`;
-            }
-            if (this.isNamedType(type)) {
-                return `${this.scalar(type.name.value)}${this.isNonNullType(parentType) ? '' : '?'}`;
-            }
-            return '';
-        };
-        this.isListType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'ListType';
-        this.isNonNullType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'NonNullType';
-        this.isNamedType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'NamedType';
-        this._config = _config;
-        this._appliesOn = _appliesOn;
-        this._node = _node;
-        this._field = _field;
-        this._freezedConfigValue = new FreezedConfigValue(_config, _node.name.value);
-    }
-    init() {
-        this.setComment().setDecorators().setRequired().setType().setName().setShape().setBlock();
-        return this;
-    }
-    setComment() {
-        var _a;
-        const comment = (_a = this._field.description) === null || _a === void 0 ? void 0 : _a.value;
-        if (comment && comment !== null && comment !== '') {
-            this._comment = indent(`/// ${comment}\n`, 2);
-        }
-        return this;
-    }
-    setDecorators() {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const nodeName = this._node.name.value;
-        const fieldName = this._field.name.value;
-        // determine if should mark as deprecated
-        const isDeprecated = (_d = (_c = (_b = (_a = this._config.typeSpecificFreezedConfig) === null || _a === void 0 ? void 0 : _a[nodeName]) === null || _b === void 0 ? void 0 : _b.fields) === null || _c === void 0 ? void 0 : _c[fieldName]) === null || _d === void 0 ? void 0 : _d.deprecated;
-        const defaultValue = (_h = (_g = (_f = (_e = this._config.typeSpecificFreezedConfig) === null || _e === void 0 ? void 0 : _e[nodeName]) === null || _f === void 0 ? void 0 : _f.fields) === null || _g === void 0 ? void 0 : _g[fieldName]) === null || _h === void 0 ? void 0 : _h.defaultValue;
-        if (this._freezedConfigValue.get('alwaysUseJsonKeyName') || fieldName !== camelCase(fieldName)) {
-            this._decorators = [...this._decorators, `@JsonKey(name: '${fieldName}')\n`];
-        }
-        this._decorators = [
-            ...this._decorators,
-            ...transformCustomDecorators(getCustomDecorators(this._config, this._appliesOn, this._node.name.value, fieldName), this._node, this._field),
-        ];
-        // @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'];
-        }
-        // @Default
-        if (defaultValue) {
-            //overwrite the customDecorator's defaultValue
-            this._decorators = this._decorators.filter(d => !d.startsWith('@Default'));
-            this._decorators = [...this._decorators, `@Default(value: ${defaultValue})\n`];
-        }
-        return this;
-    }
-    setRequired() {
-        this._required = this.isNonNullType(this._field.type);
-        return this;
-    }
-    setType() {
-        this._type = this.propertyType(this._field, this._field.type);
-        return this;
-    }
-    setName() {
-        this._name = camelCase(this._field.name.value);
-        return this;
+export class ParameterBlock {
+    static build(config, node, field, blockAppliesOn) {
+        const typeName = TypeName.fromString(node.name.value);
+        const fieldName = FieldName.fromString(field.name.value);
+        const parameterName = Block.buildBlockName(config, blockAppliesOn, fieldName.value, typeName, fieldName, 'camelCase');
+        let block = '';
+        block += Block.buildComment(field);
+        block += this.buildDecorators(config, typeName, fieldName, parameterName, blockAppliesOn);
+        block += this.buildBody(config, field, typeName, fieldName, parameterName, blockAppliesOn);
+        // return indentMultiline(block, 2);
+        return block;
     }
-    /** compose the freezed constructor property */
-    setShape() {
-        var _a, _b, _c, _d;
-        let shape = '';
-        const nodeName = this._node.name.value;
-        const fieldName = this._field.name.value;
-        // determine if should mark as final
-        const isFinal = this._decorators.includes('final') ||
-            ((_d = (_c = (_b = (_a = this._config.typeSpecificFreezedConfig) === null || _a === void 0 ? void 0 : _a[nodeName]) === null || _b === void 0 ? void 0 : _b.fields) === null || _c === void 0 ? void 0 : _c[fieldName]) === null || _d === void 0 ? void 0 : _d.final);
-        //append comment
-        shape += this._comment;
-        // append the decorators
-        shape += this._decorators
-            .filter(d => d !== 'final')
-            .map(d => indent(d, 2))
-            .join('');
-        // append required for non-nullable types
-        shape += indent(this._required ? 'required ' : '', 2);
-        // append isFinal
-        shape += isFinal ? 'final ' : '';
-        // append the Dart Type, name and trailing comma
-        shape += `${this._type} ${this._name},\n`;
-        // store it in the shape
-        this._shape = shape;
-        return this;
-    }
-    /** composes the full block */
-    setBlock() {
-        this._block = this._shape;
-        return this;
+}
+_a = ParameterBlock;
+ParameterBlock.buildDecorators = (config, typeName, fieldName, parameterName, blockAppliesOn) => {
+    const deprecatedDecorator = Config.deprecated(config, blockAppliesOn, typeName, fieldName);
+    const defaultValueDecorator = Config.defaultValues(config, blockAppliesOn, typeName, fieldName);
+    const jsonKeyDecorator = atJsonKeyDecorator({
+        name: fieldName.value !== parameterName ? fieldName.value : undefined,
+    });
+    return [
+        deprecatedDecorator,
+        defaultValueDecorator,
+        jsonKeyDecorator,
+        // TODO: add decorator for unionValueName
+    ]
+        .filter(decorator => stringIsNotEmpty(decorator))
+        .map(decorator => indent(decorator, 2))
+        .join('');
+};
+ParameterBlock.buildBody = (config, field, typeName, fieldName, parameterName, blockAppliesOn) => {
+    const required = _a.isNonNullType(field.type) ? 'required ' : '';
+    const final = Config.final(config, blockAppliesOn, typeName, fieldName) ? 'final ' : '';
+    const dartType = _a.parameterType(config, field.type);
+    return indent(`${required}${final}${dartType} ${parameterName},\n`, 2);
+};
+ParameterBlock.parameterType = (config, type, parentType) => {
+    if (_a.isNonNullType(type)) {
+        return _a.parameterType(config, type.type, type);
     }
-    scalar(_scalar) {
-        var _a, _b;
-        if ((_b = (_a = this._config) === null || _a === void 0 ? void 0 : _a.customScalars) === null || _b === void 0 ? void 0 : _b[_scalar]) {
-            return this._config.customScalars[_scalar];
-        }
-        if (DART_SCALARS[_scalar]) {
-            return DART_SCALARS[_scalar];
-        }
-        return _scalar;
+    if (_a.isListType(type)) {
+        const T = _a.parameterType(config, type.type, type);
+        return `List<${T}>${_a.isNonNullType(parentType) ? '' : '?'}`;
     }
-    /** returns the block */
-    toString() {
-        if (!this._block) {
-            throw new Error('FreezedParameterBlock: setShape must be called before calling toString()');
-        }
-        return this._block;
+    if (_a.isNamedType(type)) {
+        return `${Config.customScalars(config, type.name.value)}${_a.isNonNullType(parentType) ? '' : '?'}`;
     }
-}
+    return '';
+};
+ParameterBlock.isListType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'ListType';
+ParameterBlock.isNonNullType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'NonNullType';
+ParameterBlock.isNamedType = (type) => (type === null || type === void 0 ? void 0 : type.kind) === 'NamedType';

package/esm/index.js

@@ -1,22 +1,18 @@
 import { oldVisit } from '@graphql-codegen/plugin-helpers';
 import { transformSchemaAST } from '@graphql-codegen/schema-ast';
-import { FreezedDeclarationBlock } from './freezed-declaration-blocks/index.js';
+import { defaultFreezedPluginConfig } from './config/plugin-config.js';
+import { Block } from './freezed-declaration-blocks/index.js';
 import { schemaVisitor } from './schema-visitor.js';
-import { addFreezedImportStatements, DefaultFreezedPluginConfig } from './utils.js';
-export const plugin = (schema, _documents, config) => {
+export const plugin = (schema, _documents, _config, info) => {
+    var _a;
     // sets the defaults for the config
-    config = { ...new DefaultFreezedPluginConfig(config) };
+    const config = { ...defaultFreezedPluginConfig, ..._config };
     const { schema: _schema, ast } = transformSchemaAST(schema, config);
-    const { freezedFactoryBlockRepository, ...visitor } = schemaVisitor(_schema, config);
+    const { nodeRepository, ...visitor } = schemaVisitor(_schema, config);
     const visitorResult = oldVisit(ast, { leave: visitor });
-    const generated = visitorResult.definitions.filter((def) => def instanceof FreezedDeclarationBlock);
-    return (addFreezedImportStatements(config.fileName) +
-        generated
-            .map(freezedDeclarationBlock => freezedDeclarationBlock.toString().replace(/==>factory==>.+\n/gm, s => {
-            const pattern = s.replace('==>factory==>', '').trim();
-            const [key, appliesOn, name, typeName] = pattern.split('==>');
-            return freezedFactoryBlockRepository.retrieve(key, appliesOn, name, typeName !== null && typeName !== void 0 ? typeName : null);
-        }))
-            .join('')
-            .trim());
+    const importStatements = Block.buildImportStatements((_a = info === null || info === void 0 ? void 0 : info.outputFile) !== null && _a !== void 0 ? _a : 'app_models');
+    const generatedBlocks = visitorResult.definitions.filter((def) => typeof def === 'string' && def.length > 0);
+    // return [importStatements, ...generatedBlocks].join('').trim();
+    const output = Block.replaceTokens(config, nodeRepository, generatedBlocks);
+    return [importStatements, output].join('').trim();
 };

package/esm/schema-visitor.js

@@ -1,11 +1,12 @@
-import { FreezedFactoryBlockRepository, transformDefinition } from './utils.js';
+import { Block } from './freezed-declaration-blocks/index.js';
+import { NodeRepository } from './freezed-declaration-blocks/node-repository.js';
 export const schemaVisitor = (_schema, config) => {
-    const freezedFactoryBlockRepository = new FreezedFactoryBlockRepository();
+    const nodeRepository = new NodeRepository();
     return {
-        freezedFactoryBlockRepository,
-        EnumTypeDefinition: (node) => transformDefinition(config, freezedFactoryBlockRepository, node),
-        UnionTypeDefinition: (node) => transformDefinition(config, freezedFactoryBlockRepository, node),
-        ObjectTypeDefinition: (node) => transformDefinition(config, freezedFactoryBlockRepository, node),
-        InputObjectTypeDefinition: (node) => transformDefinition(config, freezedFactoryBlockRepository, node),
+        nodeRepository,
+        EnumTypeDefinition: (node) => Block.build(config, node, nodeRepository),
+        UnionTypeDefinition: (node) => Block.build(config, node, nodeRepository),
+        ObjectTypeDefinition: (node) => Block.build(config, node, nodeRepository),
+        InputObjectTypeDefinition: (node) => Block.build(config, node, nodeRepository),
     };
 };