@kiwano/core 1.2.0 → 1.4.0

package/dist/plugin/MultiPlugin.d.ts

@@ -38,8 +38,8 @@ export declare class MultiPlugin implements Plugin {
     afterFinalizeArgument(builder: ArgumentBuilder, context: FinalizeContext, info: ArgumentBuilderInfo): Promise<void>;
     beforeBuild(rootBuilder: SchemaBuilder): void;
     afterBuild(rootBuilder: SchemaBuilder, schema: GraphQLSchema): void;
-    beforeBuildSchema(builder: SchemaBuilder): void;
-    afterBuildSchema(builder: SchemaBuilder, schema: GraphQLSchema): void;
+    beforeBuildSchema(builder: SchemaBuilder, rootBuilder: SchemaBuilder): void;
+    afterBuildSchema(builder: SchemaBuilder, schema: GraphQLSchema, rootBuilder: SchemaBuilder): void;
     beforeBuildObjectType(builder: ObjectTypeBuilder, context: BuildContext, info: ObjectTypeBuilderInfo): void;
     afterBuildObjectType(builder: ObjectTypeBuilder, context: BuildContext, info: ObjectTypeBuilderInfo, objectType: GraphQLObjectType): void;
     beforeBuildInputObjectType(builder: InputObjectTypeBuilder, context: BuildContext, info: InputObjectTypeBuilderInfo): void;

package/dist/plugin/MultiPlugin.js

@@ -88,11 +88,11 @@ class MultiPlugin {
     afterBuild(rootBuilder, schema) {
         this.executeSync('afterBuild', plugin => plugin.afterBuild(rootBuilder, schema));
     }
-    beforeBuildSchema(builder) {
-        this.executeSync('beforeBuildSchema', plugin => plugin.beforeBuildSchema(builder));
+    beforeBuildSchema(builder, rootBuilder) {
+        this.executeSync('beforeBuildSchema', plugin => plugin.beforeBuildSchema(builder, rootBuilder));
     }
-    afterBuildSchema(builder, schema) {
-        this.executeSync('afterBuildSchema', plugin => plugin.afterBuildSchema(builder, schema));
+    afterBuildSchema(builder, schema, rootBuilder) {
+        this.executeSync('afterBuildSchema', plugin => plugin.afterBuildSchema(builder, schema, rootBuilder));
     }
     beforeBuildObjectType(builder, context, info) {
         this.executeSync('beforeBuildObjectType', plugin => plugin.beforeBuildObjectType(builder, context, info));

package/dist/plugin/acl/acl.d.ts

@@ -43,8 +43,8 @@ export declare class AclPlugin implements Plugin {
     middleware(config?: AclValidateConfigType): (req: any, res: any, next: any) => void;
     rolePath(path: string): this;
     onForbidden(handler: (resource: string) => void): this;
-    beforeBuildSchema(builder: SchemaBuilder): void;
-    afterBuildSchema(builder: SchemaBuilder, schema: GraphQLSchema): void;
+    beforeBuildSchema(builder: SchemaBuilder, rootBuilder: SchemaBuilder): void;
+    afterBuildSchema(builder: SchemaBuilder, schema: GraphQLSchema, rootBuilder: SchemaBuilder): void;
     protected addRules(resource: string, allowed: Set<string>, denied: Set<string>): void;
     protected _findRules(resource: string, collection: Map<string, AclRuleConfig>): AclRuleConfig[];
     protected _learnRoles(roles: Set<AclRoleIdentifier>): void;

package/dist/plugin/acl/acl.js

@@ -129,18 +129,19 @@ class AclPlugin {
         this._options.onForbidden = handler;
         return this;
     }
-    beforeBuildSchema(builder) {
+    beforeBuildSchema(builder, rootBuilder) {
         // Add middleware
-        builder.use((0, middleware_1.graphQLAclMiddleware)(this, null, this._options));
+        builder.use((0, middleware_1.graphQLAclMiddleware)(this, rootBuilder.name || rootBuilder.tag.toString(), this._options));
     }
-    afterBuildSchema(builder, schema) {
+    afterBuildSchema(builder, schema, rootBuilder) {
         // Add rules
+        const schemaId = rootBuilder.name || rootBuilder.tag.toString();
         for (let type of builder.getObjectTypes()) {
             const typeInfo = type.info();
-            this.addRules(`${type.name}.*`, typeInfo.allowedRoles, typeInfo.deniedRoles);
+            this.addRules(`${schemaId}:${type.name}.*`, typeInfo.allowedRoles, typeInfo.deniedRoles);
             for (let field of type.info().fields) {
                 const fieldInfo = field.info();
-                this.addRules(`${type.name}.${field.name}`, fieldInfo.allowedRoles, fieldInfo.deniedRoles);
+                this.addRules(`${schemaId}:${type.name}.${field.name}`, fieldInfo.allowedRoles, fieldInfo.deniedRoles);
             }
         }
     }

package/dist/plugin/acl/middleware.d.ts

@@ -7,5 +7,5 @@ export interface AclMiddlewareOptions {
 }
 export declare const defaultAclMiddlewareOptions: AclMiddlewareOptions;
 export declare function expressAclMiddleware(acl: AclPlugin, config?: AclValidateConfigType, options?: AclMiddlewareOptions): (req: any, res: any, next: any) => void;
-export declare function graphQLAclMiddleware(acl: AclPlugin, config?: AclValidateConfigType, options?: AclMiddlewareOptions): Middleware;
+export declare function graphQLAclMiddleware(acl: AclPlugin, schemaName: string, options?: AclMiddlewareOptions): Middleware;
 export declare function getPathResource(path: Path): string;

package/dist/plugin/acl/middleware.js

@@ -24,15 +24,12 @@ function expressAclMiddleware(acl, config = null, options = null) {
     };
 }
 exports.expressAclMiddleware = expressAclMiddleware;
-function graphQLAclMiddleware(acl, config = null, options = null) {
+function graphQLAclMiddleware(acl, schemaName, options = null) {
     const fullOptions = getOptions(options);
     return (resolve, root, args, context, info) => {
         var _a;
         const pathResource = getPathResource(info.path);
-        let parsedConfig = config;
-        if (!config) {
-            parsedConfig = { resource: pathResource };
-        }
+        let parsedConfig = { resource: `${schemaName}:${pathResource}` };
         const role = (_a = (0, lodash_1.get)(context, fullOptions.rolePath)) !== null && _a !== void 0 ? _a : null;
         const allowed = acl.validate(parsedConfig, role);
         if (!allowed) {

package/dist/plugin/common.d.ts

@@ -32,8 +32,8 @@ export interface Plugin {
     afterFinalizeArgument?(builder: ArgumentBuilder, context: FinalizeContext, info: ArgumentBuilderInfo): OptionalPromise;
     beforeBuild?(rootBuilder: AbstractSchemaBuilder<any>): any;
     afterBuild?(rootBuilder: AbstractSchemaBuilder<any>, schema: GraphQLSchema): any;
-    beforeBuildSchema?(builder: AbstractSchemaBuilder<any>): any;
-    afterBuildSchema?(builder: AbstractSchemaBuilder<any>, schema: GraphQLSchema): any;
+    beforeBuildSchema?(builder: AbstractSchemaBuilder<any>, rootBuilder: AbstractSchemaBuilder<any>): any;
+    afterBuildSchema?(builder: AbstractSchemaBuilder<any>, schema: GraphQLSchema, rootBuilder: AbstractSchemaBuilder<any>): any;
     beforeBuildObjectType?(builder: ObjectTypeBuilder, context: BuildContext, info: ObjectTypeBuilderInfo): any;
     afterBuildObjectType?(builder: ObjectTypeBuilder, context: BuildContext, info: ObjectTypeBuilderInfo, objectType: GraphQLObjectType): any;
     beforeBuildInputObjectType?(builder: InputObjectTypeBuilder, context: BuildContext, info: InputObjectTypeBuilderInfo): any;

package/dist/schema.d.ts

@@ -12,6 +12,7 @@ import { Plugin } from "./plugin";
 import { Configurator, Middleware, OptionalPromise } from "./common";
 export declare abstract class AbstractSchemaBuilder<NS extends NamingStrategy> {
     protected _name?: string;
+    protected _tag: number;
     protected _plugins: Plugin[];
     protected _middleware: Middleware[];
     protected _subSchemas: AbstractSchemaBuilder<any>[];
@@ -90,6 +91,7 @@ export declare abstract class AbstractSchemaBuilder<NS extends NamingStrategy> {
     hasType(name: string, deep?: boolean): boolean;
     findResolver(typeName: string, fieldName: string): GraphQLFieldResolver<any, any>;
     get name(): string;
+    get tag(): number;
     finalize(rootSchema?: AbstractSchemaBuilder<any>): Promise<void>;
     finalizeSchema(): Promise<void>;
     build(): Promise<GraphQLSchema>;

package/dist/schema.js

@@ -30,6 +30,7 @@ class AbstractSchemaBuilder {
         this._deniedMutationRoles = new Set();
         this._queryObject = new objectType_1.ObjectTypeBuilder('Query');
         this._name = name;
+        this._tag = Math.round(Math.random() * 1000000);
         this._addDefaultScalars();
     }
     naming(strategy) {
@@ -227,6 +228,9 @@ class AbstractSchemaBuilder {
     get name() {
         return (0, Builder_1.resolveName)(this._name);
     }
+    get tag() {
+        return this._tag;
+    }
     async finalize(rootSchema) {
         const resolvedRootSchema = rootSchema || this;
         // Assign naming strategy to sub schemas as default
@@ -263,15 +267,19 @@ class AbstractSchemaBuilder {
             this._plugins.forEach(plugin => enumType.use(plugin));
         }
         // Apply rules
-        for (let objectType of this.getObjectTypes()) {
+        for (let objectType of Array.from(this._objectTypes.values())) {
             objectType.allow(...Array.from(this._allowedRoles)).deny(...Array.from(this._deniedRoles));
         }
+        const fullAllowedQueryRoles = [...Array.from(this._allowedRoles), ...Array.from(this._allowedQueryRoles)];
+        const fullDeniedQueryRoles = [...Array.from(this._deniedRoles), ...Array.from(this._deniedQueryRoles)];
         for (let queryField of this._queryObject.info().fields) {
-            queryField.allow(...Array.from(this._allowedQueryRoles)).deny(...Array.from(this._deniedQueryRoles));
+            queryField.allow(...fullAllowedQueryRoles).deny(...fullDeniedQueryRoles);
         }
         if (this._mutationObject) {
+            const fullAllowedMutationRoles = [...Array.from(this._allowedRoles), ...Array.from(this._allowedMutationRoles)];
+            const fullDeniedMutationRoles = [...Array.from(this._deniedRoles), ...Array.from(this._deniedMutationRoles)];
             for (let mutationField of this._mutationObject.info().fields) {
-                mutationField.allow(...Array.from(this._allowedMutationRoles)).deny(...Array.from(this._deniedMutationRoles));
+                mutationField.allow(...fullAllowedMutationRoles).deny(...fullDeniedMutationRoles);
             }
         }
         // Finalize types
@@ -305,8 +313,8 @@ class AbstractSchemaBuilder {
         return schema;
     }
     async buildSchema(resolvedTypes, rootSchema) {
-        this._executePluginsSync('beforeBuildSchema', plugin => plugin.beforeBuildSchema(this));
         const resolvedRootSchema = rootSchema || this;
+        this._executePluginsSync('beforeBuildSchema', plugin => plugin.beforeBuildSchema(this, resolvedRootSchema));
         const context = new Builder_1.BuildContext(this, resolvedRootSchema, resolvedTypes);
         // Schema
         const schemaConfig = Object.assign(Object.assign({}, (this._customConfig || {})), { query: this._queryObject.build(context) });
@@ -324,7 +332,7 @@ class AbstractSchemaBuilder {
         const mergedSchema = (0, schema_1.mergeSchemas)({
             schemas: [fullSchema, ...builtSubSchemas]
         });
-        this._executePluginsSync('afterBuildSchema', plugin => plugin.afterBuildSchema(this, mergedSchema));
+        this._executePluginsSync('afterBuildSchema', plugin => plugin.afterBuildSchema(this, mergedSchema, resolvedRootSchema));
         return mergedSchema;
     }
     get compiledResolvers() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiwano/core",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -31,19 +31,18 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.197",
-    "graphql": "^16.8.0",
-    "rimraf": "^5.0.1",
-    "typescript": "^5.1.6"
+    "@types/lodash": "^4.17.0",
+    "graphql": "^16.8.1",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.4.3"
   },
   "dependencies": {
-    "@graphql-tools/schema": "^10.0.0",
+    "@graphql-tools/schema": "^10.0.3",
     "graphql-middleware": "^6.1.35",
     "lodash": "^4.17.21",
     "pluralize": "^8.0.0"
   },
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "gitHead": "8c06d628d7cfaddff14bbd8fc08fefb1d9be0118"
+  }
 }