@kiwano/core 2.2.0-beta.2 → 3.0.0-beta.2

package/dist/Builder.js

@@ -1,113 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalizeContext = exports.BuildContext = exports.BuilderError = void 0;
-exports.resolveName = resolveName;
-const lodash_1 = require("lodash");
-const graphql_1 = require("graphql");
-const FrameworkError_1 = __importDefault(require("./error/FrameworkError"));
-class BuilderError extends FrameworkError_1.default {
-}
-exports.BuilderError = BuilderError;
-class Builder {
-    constructor(name = null) {
-        this._plugins = [];
-        this._finalized = false;
-        this._name = name;
-    }
-    use(...plugins) {
-        plugins.forEach(plugin => this._plugins.push(plugin));
-        return this;
-    }
-    async _executePlugins(methodName, fn) {
-        for (let plugin of this._plugins) {
-            if (plugin[methodName]) {
-                await fn(plugin);
-            }
-        }
-    }
-    _executePluginsSync(methodName, fn) {
-        for (let plugin of this._plugins) {
-            if (plugin[methodName]) {
-                fn(plugin);
-            }
-        }
-    }
-    get name() {
-        return resolveName(this._name);
-    }
-    async finalize(context) {
-        if (this._finalized) {
-            return;
-        }
-        await this.finalizeBuilder(context);
-        this._finalized = true;
-    }
-}
-exports.default = Builder;
-class BuildContext {
-    constructor(schema, rootSchema, resolvedTypes) {
-        this.schema = schema;
-        this.rootSchema = rootSchema;
-        this.resolvedTypes = resolvedTypes;
-    }
-    getType(name) {
-        var _a;
-        if (this.resolvedTypes.has(name)) {
-            return this.resolvedTypes.get(name);
-        }
-        const typeResult = (_a = this.schema.locateType(name, false)) !== null && _a !== void 0 ? _a : this.rootSchema.locateType(name, true);
-        if (!typeResult) {
-            return null;
-        }
-        const { type, schema } = typeResult;
-        let resolvedType = null;
-        if (type instanceof Builder) {
-            let context = this;
-            if (schema != this.schema) {
-                context = new BuildContext(schema, this.rootSchema, this.resolvedTypes);
-            }
-            resolvedType = type.build(context);
-        }
-        else if (type instanceof graphql_1.GraphQLScalarType) {
-            resolvedType = type;
-        }
-        if (!resolvedType) {
-            throw new BuilderError(`Type ${name} not found`);
-        }
-        this.resolvedTypes.set(name, resolvedType);
-        return resolvedType;
-    }
-    getResolver(typeName, fieldName) {
-        return this.schema.findResolver(typeName, fieldName);
-    }
-}
-exports.BuildContext = BuildContext;
-class FinalizeContext {
-    constructor(schema, rootSchema) {
-        this.schema = schema;
-        this.rootSchema = rootSchema;
-    }
-    async getType(name) {
-        var _a;
-        const typeResult = (_a = this.schema.locateType(name, false)) !== null && _a !== void 0 ? _a : this.rootSchema.locateType(name, true);
-        if (!typeResult) {
-            return null;
-        }
-        const { type, schema } = typeResult;
-        if (type instanceof Builder) {
-            let context = this;
-            if (schema != this.schema) {
-                context = new FinalizeContext(schema, this.rootSchema);
-            }
-            await type.finalize(context);
-        }
-        return type;
-    }
-}
-exports.FinalizeContext = FinalizeContext;
-function resolveName(name) {
-    return (0, lodash_1.isFunction)(name) ? name() : name;
-}

package/dist/argument.js

@@ -1,100 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentBuilder = void 0;
-exports.argument = argument;
-const lodash_1 = require("lodash");
-const graphql_1 = require("graphql");
-const Builder_1 = __importDefault(require("./Builder"));
-const util_1 = require("./util");
-class ArgumentBuilder extends Builder_1.default {
-    constructor(name, type) {
-        super(name);
-        this._extensions = new Map();
-        this._nonNull = false;
-        this._nonNullList = false;
-        this._list = false;
-        this.type(type);
-    }
-    type(type) {
-        const resolvedType = (0, util_1.resolveType)(type);
-        this._type = resolvedType.type;
-        if (resolvedType.nonNull)
-            this.nonNull();
-        if (resolvedType.list)
-            this.list();
-        if (resolvedType.nonNullList)
-            this.nonNullList();
-        return this;
-    }
-    description(description) {
-        this._description = description;
-        return this;
-    }
-    extension(name, value) {
-        this._extensions.set(name, value);
-        return this;
-    }
-    nonNull(nonNull = true) {
-        this._nonNull = nonNull;
-        return this;
-    }
-    list(list = true) {
-        this._list = list;
-        return this;
-    }
-    nonNullList(nonNullList = true) {
-        if (nonNullList) {
-            this.list();
-        }
-        this._nonNullList = nonNullList;
-        return this;
-    }
-    async finalizeBuilder(context) {
-        const info = this.info();
-        await this._executePlugins('beforeFinalizeArgument', plugin => plugin.beforeFinalizeArgument(this, context, info));
-        await this.finalizeArgument(context, info);
-        await this._executePlugins('afterFinalizeArgument', plugin => plugin.afterFinalizeArgument(this, context, info));
-    }
-    async finalizeArgument(context, info) { }
-    build(context) {
-        const info = this.info();
-        this._executePluginsSync('beforeBuildArgument', plugin => plugin.beforeBuildArgument(this, context, info));
-        let type = (0, lodash_1.isString)(this._type) ? context.getType(this._type) : this._type;
-        if (this._list) {
-            if (this._nonNullList) {
-                type = new graphql_1.GraphQLNonNull(type);
-            }
-            type = new graphql_1.GraphQLList(type);
-        }
-        if (this._nonNull) {
-            type = new graphql_1.GraphQLNonNull(type);
-        }
-        const argument = {
-            type,
-            description: this._description,
-            extensions: Object.assign({}, Object.fromEntries(this._extensions))
-        };
-        this._executePluginsSync('afterBuildArgument', plugin => plugin.afterBuildArgument(this, context, info, argument));
-        return argument;
-    }
-    info() {
-        return {
-            name: this.name,
-            type: this._type,
-            description: this._description,
-            extensions: new Map(this._extensions),
-            nonNull: this._nonNull,
-            nonNullList: this._nonNullList,
-            list: this._list,
-            plugins: (0, lodash_1.clone)(this._plugins)
-        };
-    }
-}
-exports.ArgumentBuilder = ArgumentBuilder;
-function argument(name, type) {
-    return new ArgumentBuilder(name, type);
-}
-exports.default = argument;

package/dist/common.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entity/createInputObjectType.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateInputObjectTypeBuilder = void 0;
-exports.createInputObjectType = createInputObjectType;
-const inputObjectType_1 = require("../inputObjectType");
-const objectType_1 = require("../objectType");
-const inputField_1 = require("../inputField");
-const util_1 = require("../util");
-class CreateInputObjectTypeBuilder extends inputObjectType_1.InputObjectTypeBuilder {
-    constructor(name, entityType) {
-        super(name);
-        this._exclude = new Set();
-        this._include = new Set();
-        this._entityObjectType = entityType;
-    }
-    exclude(...fieldNames) {
-        fieldNames.forEach(name => this._exclude.add(name));
-        return this;
-    }
-    include(...fieldNames) {
-        fieldNames.forEach(name => this._include.add(name));
-        return this;
-    }
-    async finalizeInputObjectType(context, info) {
-        await super.finalizeInputObjectType(context, info);
-        const entity = this._entityObjectType instanceof objectType_1.ObjectTypeBuilder ? this._entityObjectType : this._entityObjectType();
-        const entityInfo = entity.info();
-        const existingFieldNames = info.fields.map(field => field.name);
-        for (let field of entityInfo.fields) {
-            const fieldInfo = field.info();
-            if (!(0, util_1.isTypeInput)(fieldInfo.type, context.rootSchema) || (0, util_1.isFieldId)(fieldInfo) || existingFieldNames.indexOf(fieldInfo.name) >= 0) {
-                continue;
-            }
-            if (this._exclude.has(fieldInfo.name) || (this._include.size > 0 && !this._include.has(fieldInfo.name))) {
-                continue;
-            }
-            const inputField = new inputField_1.InputFieldBuilder(fieldInfo.name, fieldInfo.type);
-            if (fieldInfo.nonNull) {
-                inputField.nonNull();
-            }
-            if (fieldInfo.list) {
-                inputField.list();
-            }
-            if (fieldInfo.nonNullList) {
-                inputField.nonNullList();
-            }
-            this.field(inputField);
-        }
-    }
-}
-exports.CreateInputObjectTypeBuilder = CreateInputObjectTypeBuilder;
-function createInputObjectType(name, entityType) {
-    return new CreateInputObjectTypeBuilder(name, entityType);
-}
-exports.default = createInputObjectType;

package/dist/entity/entitySchema.js

@@ -1,212 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchemaBuilder = exports.AbstractEntitySchemaBuilder = exports.AbstractEntitySchemaBuilderBase = exports.entityFieldTypeExtensionName = exports.EntityFieldType = void 0;
-exports.entitySchema = entitySchema;
-const objectType_1 = require("../objectType");
-const field_1 = require("../field");
-const naming_1 = require("../naming");
-const schema_1 = require("../schema");
-const util_1 = require("../util");
-const createInputObjectType_1 = require("./createInputObjectType");
-const updateInputObjectType_1 = require("./updateInputObjectType");
-var EntityFieldType;
-(function (EntityFieldType) {
-    EntityFieldType["ALL"] = "ALL";
-    EntityFieldType["FIND"] = "FIND";
-    EntityFieldType["CREATE"] = "CREATE";
-    EntityFieldType["UPDATE"] = "UPDATE";
-    EntityFieldType["DELETE"] = "DELETE";
-    EntityFieldType["RESTORE"] = "RESTORE";
-    EntityFieldType["RELATION"] = "RELATION";
-})(EntityFieldType || (exports.EntityFieldType = EntityFieldType = {}));
-exports.entityFieldTypeExtensionName = "$entityFieldType";
-class AbstractEntitySchemaBuilderBase extends schema_1.AbstractSchemaBuilder {
-    constructor() {
-        super(...arguments);
-        this._allowedEntityRoles = new Set();
-        this._deniedEntityRoles = new Set();
-    }
-    entity(builderOrConfiguratorOrName, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, objectType_1.ObjectTypeBuilder);
-        const defaultName = () => this.namingStrategy.entityObject(this.name);
-        this._entityObjectType = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createEntityObjectType(name || defaultName));
-        return this;
-    }
-    all(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.allField(this.name);
-        this._allField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createAllField(name || defaultName));
-        return this;
-    }
-    find(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.findField(this.name);
-        this._findField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createFindField(name || defaultName));
-        return this;
-    }
-    create(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.createField(this.name);
-        this._createField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createCreateField(name || defaultName));
-        return this;
-    }
-    update(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.updateField(this.name);
-        this._updateField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createUpdateField(name || defaultName));
-        return this;
-    }
-    delete(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.deleteField(this.name);
-        this._deleteField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createDeleteField(name || defaultName));
-        return this;
-    }
-    restore(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.restoreField(this.name);
-        this._restoreField = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createRestoreField(name || defaultName));
-        return this;
-    }
-    allowEntity(...roles) {
-        roles.forEach(role => this._allowedEntityRoles.add(role));
-        return this;
-    }
-    denyEntity(...roles) {
-        roles.forEach(role => this._deniedEntityRoles.add(role));
-        return this;
-    }
-    entityResolvers(resolvers) {
-        this._entityResolvers = resolvers;
-        return this;
-    }
-    async finalizeSchema() {
-        await super.finalizeSchema();
-        // Create default entity object when no object provided
-        if (!this._entityObjectType) {
-            this._entityObjectType = this.createEntityObjectType(this.namingStrategy.entityObject(this.name));
-        }
-        // Add rules & plugins
-        this._entityObjectType.allow(...Array.from(this._allowedEntityRoles)).deny(...Array.from(this._deniedEntityRoles));
-        this.object(this._entityObjectType);
-        // Set type in fields
-        if (this._allField) {
-            this._allField.type(this._entityObjectType.name);
-            this._allField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.ALL);
-            this.query(this._allField);
-        }
-        if (this._findField) {
-            this._findField.type(this._entityObjectType.name);
-            this._findField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.FIND);
-            this.query(this._findField);
-        }
-        if (this._createField) {
-            this._createField.type(this._entityObjectType.name);
-            this._createField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.CREATE);
-            this.mutation(this._createField);
-        }
-        if (this._updateField) {
-            this._updateField.type(this._entityObjectType.name);
-            this._updateField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.UPDATE);
-            this.mutation(this._updateField);
-        }
-        if (this._deleteField) {
-            this._deleteField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.DELETE);
-            this.mutation(this._deleteField);
-        }
-        if (this._restoreField) {
-            this._restoreField.type(this._entityObjectType.name);
-            this._restoreField.extension(exports.entityFieldTypeExtensionName, EntityFieldType.RESTORE);
-            this.mutation(this._restoreField);
-        }
-        // Entity resolvers
-        if (this._entityResolvers) {
-            this._resolvers = Object.assign({ [this._entityObjectType.name]: (0, util_1.ensureInstantiated)(this._entityResolvers) }, this._resolvers);
-        }
-    }
-}
-exports.AbstractEntitySchemaBuilderBase = AbstractEntitySchemaBuilderBase;
-class AbstractEntitySchemaBuilder extends AbstractEntitySchemaBuilderBase {
-    createInput(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.createInputObject(this.name);
-        this._createInputObject = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createCreateInputObject(name || defaultName));
-        return this;
-    }
-    updateInput(builderOrConfiguratorOrName = null, configurator = null) {
-        let resolvedArgs = (0, util_1.resolveAutoBuilderArgs)(builderOrConfiguratorOrName, configurator, field_1.FieldBuilder);
-        const defaultName = () => this.namingStrategy.updateInputObject(this.name);
-        this._updateInputObject = (0, util_1.resolveBuilder)(resolvedArgs, name => this.createUpdateInputObject(name || defaultName));
-        return this;
-    }
-    async finalizeSchema() {
-        await super.finalizeSchema();
-        if (this._findField) {
-            this._findField.arg(this.namingStrategy.findFieldIdArgument(this.name), 'ID', _ => _.nonNull());
-        }
-        if (this._deleteField) {
-            this._deleteField.arg(this.namingStrategy.deleteFieldIdArgument(this.name), 'ID', _ => _.nonNull());
-        }
-        if (this._restoreField) {
-            this._restoreField.arg(this.namingStrategy.restoreFieldIdArgument(this.name), 'ID', _ => _.nonNull());
-        }
-        if (this._createField) {
-            if (!this._createInputObject) {
-                this._createInputObject = this.createCreateInputObject(this.namingStrategy.createInputObject(this.name));
-            }
-            this._createField.arg(this.namingStrategy.createFieldInputArgument(this.name), this._createInputObject.name, _ => _.nonNull());
-        }
-        if (this._createInputObject) {
-            this.inputObject(this._createInputObject);
-        }
-        if (this._updateField) {
-            if (!this._updateInputObject) {
-                this._updateInputObject = this.createUpdateInputObject(this.namingStrategy.updateInputObject(this.name));
-            }
-            this._updateField.arg(this.namingStrategy.updateFieldInputArgument(this.name), this._updateInputObject.name, _ => _.nonNull());
-        }
-        if (this._updateInputObject) {
-            this.inputObject(this._updateInputObject);
-        }
-    }
-}
-exports.AbstractEntitySchemaBuilder = AbstractEntitySchemaBuilder;
-class EntitySchemaBuilder extends AbstractEntitySchemaBuilder {
-    constructor(name = null) {
-        super(name);
-        this._defaultNamingStrategy = EntitySchemaBuilder.defaultNamingStrategy;
-    }
-    createEntityObjectType(name) {
-        return new objectType_1.ObjectTypeBuilder(name);
-    }
-    createAllField(name) {
-        return new field_1.FieldBuilder(name).list();
-    }
-    createFindField(name) {
-        return new field_1.FieldBuilder(name);
-    }
-    createCreateField(name) {
-        return new field_1.FieldBuilder(name);
-    }
-    createUpdateField(name) {
-        return new field_1.FieldBuilder(name);
-    }
-    createDeleteField(name) {
-        return new field_1.FieldBuilder(name, 'Boolean');
-    }
-    createRestoreField(name) {
-        return new field_1.FieldBuilder(name);
-    }
-    createCreateInputObject(name) {
-        return new createInputObjectType_1.CreateInputObjectTypeBuilder(name, () => this._entityObjectType);
-    }
-    createUpdateInputObject(name) {
-        return new updateInputObjectType_1.UpdateInputObjectTypeBuilder(name, () => this._entityObjectType);
-    }
-}
-exports.EntitySchemaBuilder = EntitySchemaBuilder;
-EntitySchemaBuilder.defaultNamingStrategy = (0, naming_1.compactNamingStrategy)();
-function entitySchema(name) {
-    return new EntitySchemaBuilder(name);
-}
-exports.default = entitySchema;

package/dist/entity/index.js

@@ -1,24 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const entitySchema_1 = __importDefault(require("./entitySchema"));
-__exportStar(require("./createInputObjectType"), exports);
-__exportStar(require("./entitySchema"), exports);
-__exportStar(require("./updateInputObjectType"), exports);
-exports.default = entitySchema_1.default;

package/dist/entity/updateInputObjectType.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateInputObjectTypeBuilder = void 0;
-exports.updateInputObjectType = updateInputObjectType;
-const inputObjectType_1 = require("../inputObjectType");
-const objectType_1 = require("../objectType");
-const inputField_1 = require("../inputField");
-const util_1 = require("../util");
-class UpdateInputObjectTypeBuilder extends inputObjectType_1.InputObjectTypeBuilder {
-    constructor(name, entityType) {
-        super(name);
-        this._exclude = new Set();
-        this._include = new Set();
-        this._entityObjectType = entityType;
-    }
-    exclude(...fieldNames) {
-        fieldNames.forEach(name => this._exclude.add(name));
-        return this;
-    }
-    include(...fieldNames) {
-        fieldNames.forEach(name => this._include.add(name));
-        return this;
-    }
-    async finalizeInputObjectType(context, info) {
-        await super.finalizeInputObjectType(context, info);
-        const entity = this._entityObjectType instanceof objectType_1.ObjectTypeBuilder ? this._entityObjectType : this._entityObjectType();
-        const entityInfo = entity.info();
-        const existingFieldNames = info.fields.map(field => field.name);
-        for (let field of entityInfo.fields) {
-            const fieldInfo = field.info();
-            if (!(0, util_1.isTypeInput)(fieldInfo.type, context.rootSchema) || existingFieldNames.indexOf(fieldInfo.name) >= 0) {
-                continue;
-            }
-            if (this._exclude.has(fieldInfo.name) || (this._include.size > 0 && !this._include.has(fieldInfo.name))) {
-                continue;
-            }
-            const inputField = new inputField_1.InputFieldBuilder(fieldInfo.name, fieldInfo.type);
-            if ((0, util_1.isFieldId)(fieldInfo)) {
-                inputField.nonNull();
-            }
-            if (fieldInfo.list) {
-                inputField.list();
-            }
-            if (fieldInfo.nonNullList) {
-                inputField.nonNullList();
-            }
-            this.field(inputField);
-        }
-    }
-}
-exports.UpdateInputObjectTypeBuilder = UpdateInputObjectTypeBuilder;
-function updateInputObjectType(name, entityType) {
-    return new UpdateInputObjectTypeBuilder(name, entityType);
-}
-exports.default = updateInputObjectType;