ExtraInitializers.ejs

#if DEBUG
import ApolloAPI

<%_ for (const type of types.structs.filter(type => type.accessLevel === "public")) {
	const packageName = "<YOUR PACKAGE NAME HERE>"
	const filterFunc = variable => {
		if (!variable.isComputed) return false
				if (variable.isStatic) return false
				if (typeof variable.type === 'undefined') return true
				return variable.type.inheritedTypes.indexOf(`${packageName}.InlineFragment`) === -1
	}
	const valueForData = variable => {
		if (typeof variable.typeName.array?.elementType !== 'undefined') {
			return `${variable.name}.map { $0.__data._data }`
		}
		if (typeof variable.type === 'undefined') {
			return variable.name // it's a scalar!
		}
		if (variable.typeName.isOptional) {
			return `${variable.name}?.__data._data`
		}
		return `${variable.name}.__data._data`
	}
	const vars = type.variables.filter(filterFunc)
	if (type.inheritedTypes.indexOf(`${packageName}.SelectionSet`) !== -1) { _%>
// SELECTION SET
public extension <%- type.name %> {
	init(<%- vars
		.map((variable) => {
			let defaultValue = ""
			if (variable.defaultValue) {
				defaultValue = ` = ${variable.defaultValue}`
			} else if (variable.typeName.isOptional) {
				defaultValue = " = nil"
			}
			return `${variable.name}: ${variable.typeName.name}${defaultValue}`
		})
		.join(", ")
	%>) {
		var data = ApolloAPI.JSONObject()
		data["__typename"] = "<%- type.localName %>"
		<%_ for (const variable of vars) { _%>
		data["<%- variable.name %>"] = <%- valueForData(variable) %>
		<%_ } _%>
		self.init(data: DataDict(data, variables: nil))
	}
}

<%_ } else if (type.inheritedTypes.indexOf(`${packageName}.InlineFragment`) !== -1) {
	const baseName = type.localName.replace(/^As/,"")_%>
// INLINE FRAGMENT
public extension <%- type.name %> {
	static func make(<%-	vars
		.map((variable) => {
			let defaultValue = ""
			if (variable.defaultValue) {
				defaultValue = ` = ${variable.defaultValue}`
			} else if (variable.typeName.isOptional) {
				defaultValue = " = nil"
			}
			return `${variable.name}: ${variable.typeName.name}${defaultValue}`
		})
		.join(", ")
																														%>) -> <%- type.parent.name %> {
		var data = ApolloAPI.JSONObject()
		data["__typename"] = "<%- baseName %>"
		<%_ for (const variable of type.variables.filter(variable => variable.isComputed && !variable.isStatic)) { _%>
		data["<%- variable.name %>"] = <%- valueForData(variable) %>
		<%_ } _%>
		return <%- type.parent.name %>(data: DataDict(data, variables: nil))
	}
}

<%_ } else if (type.inheritedTypes.indexOf("FragmentContainer") !== -1) {
	const variablesToRemove = new Set()
	for (const fragment of vars) {
		for (const variable of fragment.type.variables.filter(filterFunc)) {
			variablesToRemove.add(variable.name)
		}
	}
	const effectiveVars = type.parent.variables.filter(filterFunc)
		.filter(variable => !variablesToRemove.has(variable.name))
		
	
	_%>
// FRAGMENT CONTAINER: <%= type.name %>
public extension <%- type.parent.name %> {
	init(<%- effectiveVars.concat(vars)
		.map((variable) => {
			let defaultValue = ""
			if (variable.defaultValue) {
				defaultValue = ` = ${variable.defaultValue}`
			} else if (variable.typeName.isOptional) {
				defaultValue = " = nil"
			}
			return `${variable.name}: ${variable.typeName.name}${defaultValue}`
		})
		.join(", ")
	%>) {
		var data = ApolloAPI.JSONObject()
		data["__typename"] = "<%- type.parent.localName %>"
		<%_ for (const variable of effectiveVars) { _%>
		data["<%- variable.name %>"] = <%- valueForData(variable) %>
		<%_ } _%>
<%# Note that `vars` here is the list of fragments, so we have to loop through *their* variables in turn _%>
		<%_ for (const fragment of vars) { _%>
			<%_	for (const variable of fragment.type.variables.filter(filterFunc)) { _%>
		data["<%- variable.name %>"] = <%-fragment.name%>.<%- variable.name %>
			<%_ }_%>
		<%_	}_%>
		self.init(data: DataDict(data, variables: nil))
	}
}

<%_ } _%>
<%_ } _%>
#endif