@kiwano/core 0.1.2 → 1.0.0

package/{Builder.d.ts → dist/Builder.d.ts}

@@ -6,8 +6,8 @@ import { Configurator, OptionalPromise } from "./common";
 import { AbstractSchemaBuilder } from "./schema";
 export declare class BuilderError extends FrameworkError {
 }
-export declare type BuilderOrConfiguratorOrName<T> = T | Configurator<T> | string;
-export declare type BuilderName = string | (() => string);
+export type BuilderOrConfiguratorOrName<T> = T | Configurator<T> | string;
+export type BuilderName = string | (() => string);
 export declare const builderInfoExtensionName = "$builder";
 export default abstract class Builder<RT> {
     protected _name?: BuilderName;

package/{argument.d.ts → dist/argument.d.ts}

@@ -1,7 +1,7 @@
 import { GraphQLArgumentConfig, GraphQLInputType } from "graphql/type/definition";
 import Builder, { BuildContext, FinalizeContext, BuilderName } from "./Builder";
 import { Plugin } from "./plugin";
-export declare type ArgumentType = string | GraphQLInputType;
+export type ArgumentType = string | GraphQLInputType;
 export interface ArgumentBuilderInfo {
     name: string;
     type: ArgumentType;

package/{argument.js → dist/argument.js}

@@ -84,12 +84,12 @@ class ArgumentBuilder extends Builder_1.default {
         let type = (0, lodash_1.isString)(this._type) ? context.getType(this._type) : this._type;
         if (this._list) {
             if (this._nonNullList) {
-                type = (0, graphql_1.GraphQLNonNull)(type);
+                type = new graphql_1.GraphQLNonNull(type);
             }
-            type = (0, graphql_1.GraphQLList)(type);
+            type = new graphql_1.GraphQLList(type);
         }
         if (this._nonNull) {
-            type = (0, graphql_1.GraphQLNonNull)(type);
+            type = new graphql_1.GraphQLNonNull(type);
         }
         const argument = {
             type,

package/dist/common.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLResolveInfo } from "graphql";
+export { IMiddleware as Middleware } from "graphql-middleware/dist/types";
+export type ConstructorType<T> = new (...args: any[]) => T;
+export type OptionalPromise<T = void> = Promise<T> | T;
+export type Configurator<T> = (object: T) => T | void;
+export type AnyObject = Record<string, any>;
+export type Optional<T> = T | void;
+export interface ResolverInfo<ST> {
+    source: ST;
+    args: AnyObject;
+    context: any;
+    info: GraphQLResolveInfo;
+}

package/{entity → dist/entity}/entitySchema.d.ts

@@ -7,23 +7,25 @@ import { AbstractSchemaBuilder } from "../schema";
 import { CreateInputObjectTypeBuilder } from "./createInputObjectType";
 import { UpdateInputObjectTypeBuilder } from "./updateInputObjectType";
 import { Configurator } from "../common";
-export declare type EntityType = ObjectTypeBuilder | (() => ObjectTypeBuilder);
+export type EntityType = ObjectTypeBuilder | (() => ObjectTypeBuilder);
 export declare enum EntityFieldType {
     ALL = "ALL",
     FIND = "FIND",
     CREATE = "CREATE",
     UPDATE = "UPDATE",
     DELETE = "DELETE",
+    RESTORE = "RESTORE",
     RELATION = "RELATION"
 }
 export declare const entityFieldTypeExtensionName = "$entityFieldType";
-export declare abstract class AbstractEntitySchemaBuilderBase<NS extends EntityNamingStrategyBase, OT extends ObjectTypeBuilder, FT extends FieldBuilder> extends AbstractSchemaBuilder<NS> {
+export declare abstract class AbstractEntitySchemaBuilderBase<NS extends EntityNamingStrategyBase, OT extends ObjectTypeBuilder, AFT extends FieldBuilder, FFT extends FieldBuilder, CFT extends FieldBuilder, UFT extends FieldBuilder, DFT extends FieldBuilder, RFT extends FieldBuilder> extends AbstractSchemaBuilder<NS> {
     protected _entityObjectType?: OT;
-    protected _allField?: FT;
-    protected _findField?: FT;
-    protected _createField?: FT;
-    protected _updateField?: FT;
-    protected _deleteField?: FT;
+    protected _allField?: AFT;
+    protected _findField?: FFT;
+    protected _createField?: CFT;
+    protected _updateField?: UFT;
+    protected _deleteField?: DFT;
+    protected _restoreField?: RFT;
     protected _allowedEntityRoles: Set<string>;
     protected _deniedEntityRoles: Set<string>;
     protected _entityResolvers?: object;
@@ -33,47 +35,54 @@ export declare abstract class AbstractEntitySchemaBuilderBase<NS extends EntityN
     entity(builder: OT): this;
     entity(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<OT>, configurator: Configurator<OT>): this;
     all(): this;
-    all(configurator: Configurator<FT>): this;
-    all(name: string, configurator: Configurator<FT>): this;
+    all(configurator: Configurator<AFT>): this;
+    all(name: string, configurator: Configurator<AFT>): this;
     all(name: string): this;
-    all(builder: FT): this;
-    all(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FT>, configurator: Configurator<FT>): this;
+    all(builder: AFT): this;
+    all(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<AFT>, configurator: Configurator<AFT>): this;
     find(): this;
-    find(configurator: Configurator<FT>): this;
-    find(name: string, configurator: Configurator<FT>): this;
+    find(configurator: Configurator<FFT>): this;
+    find(name: string, configurator: Configurator<FFT>): this;
     find(name: string): this;
-    find(builder: FT): this;
-    find(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FT>, configurator: Configurator<FT>): this;
+    find(builder: FFT): this;
+    find(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FFT>, configurator: Configurator<FFT>): this;
     create(): this;
-    create(configurator: Configurator<FT>): this;
-    create(name: string, configurator: Configurator<FT>): this;
+    create(configurator: Configurator<CFT>): this;
+    create(name: string, configurator: Configurator<CFT>): this;
     create(name: string): this;
-    create(builder: FT): this;
-    create(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FT>, configurator: Configurator<FT>): this;
+    create(builder: CFT): this;
+    create(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<CFT>, configurator: Configurator<CFT>): this;
     update(): this;
-    update(configurator: Configurator<FT>): this;
-    update(name: string, configurator: Configurator<FT>): this;
+    update(configurator: Configurator<UFT>): this;
+    update(name: string, configurator: Configurator<UFT>): this;
     update(name: string): this;
-    update(builder: FT): this;
-    update(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FT>, configurator: Configurator<FT>): this;
+    update(builder: UFT): this;
+    update(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<UFT>, configurator: Configurator<UFT>): this;
     delete(): this;
-    delete(configurator: Configurator<FT>): this;
-    delete(name: string, configurator: Configurator<FT>): this;
+    delete(configurator: Configurator<DFT>): this;
+    delete(name: string, configurator: Configurator<DFT>): this;
     delete(name: string): this;
-    delete(builder: FT): this;
-    delete(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<FT>, configurator: Configurator<FT>): this;
+    delete(builder: DFT): this;
+    delete(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<DFT>, configurator: Configurator<DFT>): this;
+    restore(): this;
+    restore(configurator: Configurator<RFT>): this;
+    restore(name: string, configurator: Configurator<RFT>): this;
+    restore(name: string): this;
+    restore(builder: RFT): this;
+    restore(builderOrConfiguratorOrName: BuilderOrConfiguratorOrName<RFT>, configurator: Configurator<RFT>): this;
     allowEntity(...roles: string[]): this;
     denyEntity(...roles: string[]): this;
     entityResolvers(resolvers?: object): this;
     finalizeSchema(): Promise<void>;
     protected abstract createEntityObjectType(name: BuilderName): OT;
-    protected abstract createAllField(name: BuilderName): FT;
-    protected abstract createFindField(name: BuilderName): FT;
-    protected abstract createCreateField(name: BuilderName): FT;
-    protected abstract createUpdateField(name: BuilderName): FT;
-    protected abstract createDeleteField(name: BuilderName): FT;
+    protected abstract createAllField(name: BuilderName): AFT;
+    protected abstract createFindField(name: BuilderName): FFT;
+    protected abstract createCreateField(name: BuilderName): CFT;
+    protected abstract createUpdateField(name: BuilderName): UFT;
+    protected abstract createDeleteField(name: BuilderName): DFT;
+    protected abstract createRestoreField(name: BuilderName): RFT;
 }
-export declare abstract class AbstractEntitySchemaBuilder<NS extends EntityNamingStrategy, OT extends ObjectTypeBuilder, FT extends FieldBuilder, CIT extends InputObjectTypeBuilder, UIT extends InputObjectTypeBuilder> extends AbstractEntitySchemaBuilderBase<NS, OT, FT> {
+export declare abstract class AbstractEntitySchemaBuilder<NS extends EntityNamingStrategy, OT extends ObjectTypeBuilder, AFT extends FieldBuilder, FFT extends FieldBuilder, CFT extends FieldBuilder, UFT extends FieldBuilder, DFT extends FieldBuilder, RFT extends FieldBuilder, CIT extends InputObjectTypeBuilder, UIT extends InputObjectTypeBuilder> extends AbstractEntitySchemaBuilderBase<NS, OT, AFT, FFT, CFT, UFT, DFT, RFT> {
     protected _createInputObject?: CIT;
     protected _updateInputObject?: UIT;
     createInput(): this;
@@ -92,7 +101,7 @@ export declare abstract class AbstractEntitySchemaBuilder<NS extends EntityNamin
     protected abstract createCreateInputObject(name: BuilderName): CIT;
     protected abstract createUpdateInputObject(name: BuilderName): UIT;
 }
-export declare class EntitySchemaBuilder extends AbstractEntitySchemaBuilder<EntityNamingStrategy, ObjectTypeBuilder, FieldBuilder, CreateInputObjectTypeBuilder, UpdateInputObjectTypeBuilder> {
+export declare class EntitySchemaBuilder extends AbstractEntitySchemaBuilder<EntityNamingStrategy, ObjectTypeBuilder, FieldBuilder, FieldBuilder, FieldBuilder, FieldBuilder, FieldBuilder, FieldBuilder, CreateInputObjectTypeBuilder, UpdateInputObjectTypeBuilder> {
     static defaultNamingStrategy: EntityNamingStrategy;
     constructor(name?: string);
     protected createEntityObjectType(name: BuilderName): ObjectTypeBuilder;
@@ -101,6 +110,7 @@ export declare class EntitySchemaBuilder extends AbstractEntitySchemaBuilder<Ent
     protected createCreateField(name: BuilderName): FieldBuilder;
     protected createUpdateField(name: BuilderName): FieldBuilder;
     protected createDeleteField(name: BuilderName): FieldBuilder;
+    protected createRestoreField(name: BuilderName): FieldBuilder;
     protected createCreateInputObject(name: BuilderName): CreateInputObjectTypeBuilder;
     protected createUpdateInputObject(name: BuilderName): UpdateInputObjectTypeBuilder;
 }

package/{entity → dist/entity}/entitySchema.js

@@ -15,6 +15,7 @@ var EntityFieldType;
     EntityFieldType["CREATE"] = "CREATE";
     EntityFieldType["UPDATE"] = "UPDATE";
     EntityFieldType["DELETE"] = "DELETE";
+    EntityFieldType["RESTORE"] = "RESTORE";
     EntityFieldType["RELATION"] = "RELATION";
 })(EntityFieldType = exports.EntityFieldType || (exports.EntityFieldType = {}));
 exports.entityFieldTypeExtensionName = "$entityFieldType";
@@ -60,6 +61,12 @@ class AbstractEntitySchemaBuilderBase extends schema_1.AbstractSchemaBuilder {
         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;
@@ -106,6 +113,11 @@ class AbstractEntitySchemaBuilderBase extends schema_1.AbstractSchemaBuilder {
             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);
@@ -134,20 +146,27 @@ class AbstractEntitySchemaBuilder extends AbstractEntitySchemaBuilderBase {
         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.inputObject(this._createInputObject);
             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.inputObject(this._updateInputObject);
             this._updateField.arg(this.namingStrategy.updateFieldInputArgument(this.name), this._updateInputObject.name, _ => _.nonNull());
         }
+        if (this._updateInputObject) {
+            this.inputObject(this._updateInputObject);
+        }
     }
 }
 exports.AbstractEntitySchemaBuilder = AbstractEntitySchemaBuilder;
@@ -174,6 +193,9 @@ class EntitySchemaBuilder extends AbstractEntitySchemaBuilder {
     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);
     }

package/{field.d.ts → dist/field.d.ts}

@@ -19,7 +19,7 @@ export interface FieldBuilderInfo {
     plugins: Plugin[];
     resolver?: GraphQLFieldResolver<any, any>;
 }
-export declare type FieldType = string | GraphQLOutputType;
+export type FieldType = string | GraphQLOutputType;
 export declare class FieldBuilder extends Builder<GraphQLFieldConfig<any, any>> {
     protected _type: FieldType;
     protected _description?: string;

package/{field.js → dist/field.js}

@@ -134,12 +134,12 @@ class FieldBuilder extends Builder_1.default {
         }
         if (this._list) {
             if (this._nonNullList) {
-                type = (0, graphql_1.GraphQLNonNull)(type);
+                type = new graphql_1.GraphQLNonNull(type);
             }
-            type = (0, graphql_1.GraphQLList)(type);
+            type = new graphql_1.GraphQLList(type);
         }
         if (this._nonNull) {
-            type = (0, graphql_1.GraphQLNonNull)(type);
+            type = new graphql_1.GraphQLNonNull(type);
         }
         const resolver = this._resolver || context.getResolver(parentBuilder.name, this.name);
         const field = {

package/{inputField.d.ts → dist/inputField.d.ts}

@@ -1,7 +1,7 @@
 import { GraphQLInputFieldConfig, GraphQLInputType } from "graphql/type/definition";
 import Builder, { BuildContext, FinalizeContext, BuilderName } from "./Builder";
 import { Plugin } from "./plugin";
-export declare type InputFieldType = string | GraphQLInputType;
+export type InputFieldType = string | GraphQLInputType;
 export interface InputFieldBuilderInfo {
     name: string;
     type: InputFieldType;

package/{inputField.js → dist/inputField.js}

@@ -84,12 +84,12 @@ class InputFieldBuilder extends Builder_1.default {
         let type = (0, lodash_1.isString)(this._type) ? context.getType(this._type) : this._type;
         if (this._list) {
             if (this._nonNullList) {
-                type = (0, graphql_1.GraphQLNonNull)(type);
+                type = new graphql_1.GraphQLNonNull(type);
             }
-            type = (0, graphql_1.GraphQLList)(type);
+            type = new graphql_1.GraphQLList(type);
         }
         if (this._nonNull) {
-            type = (0, graphql_1.GraphQLNonNull)(type);
+            type = new graphql_1.GraphQLNonNull(type);
         }
         const inputField = {
             type,

package/{inputObjectType.d.ts → dist/inputObjectType.d.ts}

@@ -17,10 +17,10 @@ export declare class InputObjectTypeBuilder extends Builder<GraphQLInputType> {
     protected _extensions: Map<string, any>;
     description(description?: string): this;
     extension(name: string, value: any): this;
-    field(name: string, type: InputFieldType, configurator: Configurator<InputFieldBuilder>): any;
-    field(name: string, type: InputFieldType): any;
-    field(field: InputFieldBuilder): any;
-    field(fieldOrName: InputFieldBuilder | string, type: InputFieldType, configurator: Configurator<InputFieldBuilder>): any;
+    field(name: string, type: InputFieldType, configurator: Configurator<InputFieldBuilder>): this;
+    field(name: string, type: InputFieldType): this;
+    field(field: InputFieldBuilder): this;
+    field(fieldOrName: InputFieldBuilder | string, type: InputFieldType, configurator: Configurator<InputFieldBuilder>): this;
     finalizeBuilder(context: FinalizeContext): Promise<void>;
     finalizeInputObjectType(context: FinalizeContext, info: InputObjectTypeBuilderInfo): Promise<void>;
     build(context: BuildContext): GraphQLInputObjectType;

package/{naming → dist/naming}/common.d.ts

@@ -7,10 +7,12 @@ export interface EntityNamingStrategyBase extends NamingStrategy {
     createField(schemaName: string): string;
     updateField(schemaName: string): string;
     deleteField(schemaName: string): string;
+    restoreField(schemaName: string): string;
 }
 export interface EntityNamingStrategy extends EntityNamingStrategyBase {
     findFieldIdArgument(schemaName: string): string;
     deleteFieldIdArgument(schemaName: string): string;
+    restoreFieldIdArgument(schemaName: string): string;
     createInputObject(schemaName: string): string;
     createFieldInputArgument(schemaName: string): string;
     updateInputObject(schemaName: string): string;

package/{naming → dist/naming}/compact.d.ts

@@ -6,8 +6,10 @@ export declare class CompactNamingStrategy implements EntityNamingStrategy {
     createField(schemaName: string): string;
     updateField(schemaName: string): string;
     deleteField(schemaName: string): string;
+    restoreField(schemaName: string): string;
     findFieldIdArgument(schemaName: string): string;
     deleteFieldIdArgument(schemaName: string): string;
+    restoreFieldIdArgument(schemaName: string): string;
     createInputObject(schemaName: string): string;
     createFieldInputArgument(schemaName: string): string;
     updateInputObject(schemaName: string): string;

package/{naming → dist/naming}/compact.js

@@ -21,12 +21,18 @@ class CompactNamingStrategy {
     deleteField(schemaName) {
         return `delete${(0, util_1.ucFirst)(schemaName)}`;
     }
+    restoreField(schemaName) {
+        return `restore${(0, util_1.ucFirst)(schemaName)}`;
+    }
     findFieldIdArgument(schemaName) {
         return 'id';
     }
     deleteFieldIdArgument(schemaName) {
         return 'id';
     }
+    restoreFieldIdArgument(schemaName) {
+        return 'id';
+    }
     createInputObject(schemaName) {
         return `Create${(0, util_1.ucFirst)(schemaName)}Input`;
     }

package/{naming → dist/naming}/descriptive.d.ts

@@ -6,8 +6,10 @@ export declare class DescriptiveNamingStrategy implements EntityNamingStrategy {
     createField(schemaName: string): string;
     updateField(schemaName: string): string;
     deleteField(schemaName: string): string;
+    restoreField(schemaName: string): string;
     findFieldIdArgument(schemaName: string): string;
     deleteFieldIdArgument(schemaName: string): string;
+    restoreFieldIdArgument(schemaName: string): string;
     createInputObject(schemaName: string): string;
     createFieldInputArgument(schemaName: string): string;
     updateInputObject(schemaName: string): string;

package/{naming → dist/naming}/descriptive.js

@@ -21,12 +21,18 @@ class DescriptiveNamingStrategy {
     deleteField(schemaName) {
         return `delete${(0, util_1.ucFirst)(schemaName)}`;
     }
+    restoreField(schemaName) {
+        return `restore${(0, util_1.ucFirst)(schemaName)}`;
+    }
     findFieldIdArgument(schemaName) {
         return 'id';
     }
     deleteFieldIdArgument(schemaName) {
         return 'id';
     }
+    restoreFieldIdArgument(schemaName) {
+        return 'id';
+    }
     createInputObject(schemaName) {
         return `Create${(0, util_1.ucFirst)(schemaName)}Input`;
     }

package/{plugin → dist/plugin}/acl/acl.d.ts

@@ -2,7 +2,7 @@ import { AclMiddlewareOptions } from "./middleware";
 import { Plugin } from "../common";
 import { SchemaBuilder } from "../../schema";
 import { GraphQLSchema } from "graphql";
-export declare type AclRoleIdentifier = string | number;
+export type AclRoleIdentifier = string | number;
 interface AclRoleConfig {
     identifier: AclRoleIdentifier;
     parent?: AclRoleIdentifier;
@@ -20,7 +20,7 @@ export interface AclValidateConfig {
     resource?: string;
     allowedRoles?: AclRoleIdentifier[];
 }
-export declare type AclValidateConfigType = AclValidateConfig | AclRoleIdentifier | AclRoleIdentifier[];
+export type AclValidateConfigType = AclValidateConfig | AclRoleIdentifier | AclRoleIdentifier[];
 export interface AclOptions extends AclMiddlewareOptions {
     defaultAction?: AclAction;
     learn?: boolean;

package/{schema.d.ts → dist/schema.d.ts}

@@ -1,3 +1,4 @@
+import { GraphQLSchemaConfig } from "graphql/type/schema";
 import { GraphQLFieldResolver } from "graphql/type/definition";
 import { GraphQLScalarType, GraphQLSchema, GraphQLType } from "graphql";
 import { ObjectTypeBuilder } from "./objectType";
@@ -14,13 +15,14 @@ export declare abstract class AbstractSchemaBuilder<NS extends NamingStrategy> {
     protected _plugins: Plugin[];
     protected _middleware: Middleware[];
     protected _subSchemas: AbstractSchemaBuilder<any>[];
+    protected _customConfig?: Readonly<GraphQLSchemaConfig>;
     protected _defaultNamingStrategy?: NS;
     protected _namingStrategy?: NS;
     protected _objectTypes: Map<string, ObjectTypeBuilder>;
     protected _inputObjectTypes: Map<string, InputObjectTypeBuilder>;
     protected _enumTypes: Map<string, EnumTypeBuilder>;
     protected _unionTypes: Map<string, UnionTypeBuilder>;
-    protected _scalarTypes: Map<string, GraphQLScalarType>;
+    protected _scalarTypes: Map<string, GraphQLScalarType<unknown, unknown>>;
     protected _allowedRoles: Set<string>;
     protected _deniedRoles: Set<string>;
     protected _allowedQueryRoles: Set<string>;
@@ -36,6 +38,7 @@ export declare abstract class AbstractSchemaBuilder<NS extends NamingStrategy> {
     naming(strategy: NS): this;
     setDefaultNamingStrategy(strategy: NS): void;
     get namingStrategy(): NS;
+    customConfig(config: Readonly<GraphQLSchemaConfig>): this;
     object(name: string, configurator: Configurator<ObjectTypeBuilder>): this;
     object(name: string): this;
     object(object: ObjectTypeBuilder): this;

package/{schema.js → dist/schema.js}

@@ -42,6 +42,10 @@ class AbstractSchemaBuilder {
     get namingStrategy() {
         return this._namingStrategy || this._defaultNamingStrategy;
     }
+    customConfig(config) {
+        this._customConfig = config;
+        return this;
+    }
     object(objectOrName, configurator = null) {
         const resolvedArgs = (0, util_1.resolveBuilderArgs)(objectOrName, configurator, objectType_1.ObjectTypeBuilder);
         const resolvedBuilder = (0, util_1.resolveBuilder)(resolvedArgs, name => new objectType_1.ObjectTypeBuilder(name));
@@ -305,9 +309,7 @@ class AbstractSchemaBuilder {
         const resolvedRootSchema = rootSchema || this;
         const context = new Builder_1.BuildContext(this, resolvedRootSchema, resolvedTypes);
         // Schema
-        const schemaConfig = {
-            query: this._queryObject.build(context)
-        };
+        const schemaConfig = Object.assign(Object.assign({}, (this._customConfig || {})), { query: this._queryObject.build(context) });
         if (this._mutationObject) {
             schemaConfig['mutation'] = this._mutationObject.build(context);
         }

package/{unionType.d.ts → dist/unionType.d.ts}

@@ -9,7 +9,7 @@ export interface UnionTypeBuilderInfo {
     extensions: Map<string, any>;
     plugins: Plugin[];
 }
-export declare type UnionTypeMemberName = string | GraphQLOutputType;
+export type UnionTypeMemberName = string | GraphQLOutputType;
 export declare class UnionTypeBuilder extends Builder<GraphQLUnionType> {
     protected _types: Set<UnionTypeMemberName>;
     protected _description?: string;

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "@kiwano/core",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "",
-  "main": "index.js",
-  "typings": "index.d.ts",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "scripts": {
-    "build": "npm run clean && npm run compile && npm run copy",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npm run clean && npm run compile",
     "clean": "rimraf ./dist",
-    "compile": "tsc -p tsconfig.build.json",
-    "copy": "ts-node -T ../../scripts/copy.ts"
+    "compile": "tsc -p tsconfig.json",
+    "watch": "tsc --watch --preserveWatchOutput -p tsconfig.json",
+    "publish": "npm publish"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kiwano-js/kiwano.git"
   },
+  "files": [
+    "dist/**"
+  ],
   "author": "Bart Blok <bart@wittig.nl>",
   "license": "MIT",
   "bugs": {
@@ -27,11 +32,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.182",
-    "graphql": "^15.8.0",
+    "@types/lodash": "^4.14.191",
+    "graphql": "^16.6.0",
     "rimraf": "^3.0.2",
-    "ts-node": "^10.7.0",
-    "typescript": "^4.6.3"
+    "typescript": "^4.9.3"
   },
   "dependencies": {
     "@graphql-tools/schema": "^8.3.9",
@@ -40,7 +44,7 @@
     "pluralize": "^8.0.0"
   },
   "peerDependencies": {
-    "graphql": "^14.0.0 || ^15.0.0"
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "gitHead": "8c06d628d7cfaddff14bbd8fc08fefb1d9be0118"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 kiwano-js
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1 +0,0 @@
-# Kiwano

package/common.d.ts

@@ -1,13 +0,0 @@
-import { GraphQLResolveInfo } from "graphql";
-export { IMiddleware as Middleware } from "graphql-middleware/dist/types";
-export declare type ConstructorType<T> = new (...args: any[]) => T;
-export declare type OptionalPromise<T = void> = Promise<T> | T;
-export declare type Configurator<T> = (object: T) => T | void;
-export declare type AnyObject = Record<string, any>;
-export declare type Optional<T> = T | void;
-export interface ResolverInfo<ST> {
-    source: ST;
-    args: AnyObject;
-    context: any;
-    info: GraphQLResolveInfo;
-}