@gqlbase/plugins 0.0.1

package/dist/base/ModelPlugin.d.ts

@@ -0,0 +1,59 @@
+import { ITransformerPlugin } from "@gqlbase/core";
+import type { ITransformerContext } from "@gqlbase/core/context";
+import { DefinitionNode, ObjectNode } from "@gqlbase/core/definition";
+export declare const ModelDirective: {
+    readonly MODEL: "model";
+};
+export declare const ModelOperation: {
+    readonly GET: "get";
+    readonly LIST: "list";
+    readonly SYNC: "sync";
+    readonly SUBSCRIBE: "subscribe";
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly UPSERT: "upsert";
+    readonly DELETE: "delete";
+    readonly READ: "read";
+    readonly WRITE: "write";
+};
+type OperationType = (typeof ModelOperation)[keyof typeof ModelOperation];
+export declare const DEFAULT_READ_OPERATIONS: OperationType[];
+export declare const DEFAULT_WRITE_OPERATIONS: OperationType[];
+export declare const isModel: (definition: DefinitionNode) => definition is ObjectNode;
+export interface ModelPluginOptions {
+    operations: OperationType[];
+}
+export declare class ModelPlugin implements ITransformerPlugin {
+    readonly name = "ModelPlugin";
+    readonly context: ITransformerContext;
+    private _defaultOperations;
+    constructor(context: ITransformerContext, options?: ModelPluginOptions);
+    private _expandOperations;
+    private _getOperationNames;
+    private _createGetQuery;
+    private _createListQuery;
+    private _shouldSkipFieldFromMutationInput;
+    private _isBuildInScalarType;
+    /**
+     * For each field in the model
+     * 1. If has `@readOnly` or connection directives - skip
+     * 2. If scalar or enum - add to input;
+     * 3. If union - skip;
+     * 4. If object or interface - check definition;
+     *    4.1 If `@model` - skip;
+     *    4.2 If implements `Node` interface - skip
+     *    4.3 If fields are `@readOnly` - skip;
+     */
+    private _createMutationInput;
+    private _createDeleteMutationField;
+    private _createMutationField;
+    private _createMutation;
+    init(): void;
+    match(definition: DefinitionNode): definition is ObjectNode;
+    execute(definition: ObjectNode): void;
+    cleanup(definition: ObjectNode): void;
+    after(): void;
+}
+export declare const modelPlugin: (options?: ModelPluginOptions | undefined) => import("@gqlbase/core").IPluginFactory;
+export {};
+//# sourceMappingURL=ModelPlugin.d.ts.map

package/dist/base/ModelPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelPlugin.d.ts","sourceRoot":"","sources":["../../src/base/ModelPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,cAAc,EAUd,UAAU,EAEX,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,cAAc;;CAEjB,CAAC;AAEX,eAAO,MAAM,cAAc;;;;;;;;;;;CAWjB,CAAC;AAEX,KAAK,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB,EAAE,aAAa,EAAoB,CAAC;AACxE,eAAO,MAAM,wBAAwB,EAAE,aAAa,EAAmC,CAAC;AAExF,eAAO,MAAM,OAAO,GAAI,YAAY,cAAc,KAAG,UAAU,IAAI,UAElE,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,SAAgB,IAAI,iBAAiB;IACrC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,OAAO,CAAC,kBAAkB,CAAkB;gBAG1C,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE,kBAAsD;IASjE,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,iCAAiC;IAUzC,OAAO,CAAC,oBAAoB;IAI5B;;;;;;;;;OASG;IAEH,OAAO,CAAC,oBAAoB;IAkE5B,OAAO,CAAC,0BAA0B;IAYlC,OAAO,CAAC,oBAAoB;IAqB5B,OAAO,CAAC,eAAe;IAehB,IAAI;IAqBJ,KAAK,CAAC,UAAU,EAAE,cAAc;IAIhC,OAAO,CAAC,UAAU,EAAE,UAAU;IAwB9B,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAIrC,KAAK,IAAI,IAAI;CAGrB;AAED,eAAO,MAAM,WAAW,sFAAmC,CAAC"}

package/dist/base/ModelPlugin.js

@@ -0,0 +1,222 @@
+import { DirectiveDefinitionNode, DirectiveNode, EnumNode, FieldNode, InputObjectNode, InputValueNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectNode, ScalarNode, } from "@gqlbase/core/definition";
+import { createPluginFactory, InternalDirective } from "@gqlbase/core/plugins";
+import { TransformerPluginExecutionError } from "@gqlbase/shared/errors";
+import { camelCase, pascalCase, pluralize } from "@gqlbase/shared/format";
+export const ModelDirective = {
+    MODEL: "model",
+};
+export const ModelOperation = {
+    GET: "get",
+    LIST: "list",
+    SYNC: "sync",
+    SUBSCRIBE: "subscribe",
+    CREATE: "create",
+    UPDATE: "update",
+    UPSERT: "upsert",
+    DELETE: "delete",
+    READ: "read",
+    WRITE: "write",
+};
+export const DEFAULT_READ_OPERATIONS = ["get", "list"];
+export const DEFAULT_WRITE_OPERATIONS = ["create", "update", "delete"];
+export const isModel = (definition) => {
+    return definition instanceof ObjectNode && definition.hasDirective(ModelDirective.MODEL);
+};
+export class ModelPlugin {
+    name = "ModelPlugin";
+    context;
+    _defaultOperations;
+    constructor(context, options = { operations: ["read", "write"] }) {
+        this.context = context;
+        this._defaultOperations = this._expandOperations(options.operations);
+    }
+    // #region Operations
+    _expandOperations(operations) {
+        const expandedOperations = new Set();
+        for (const operation of operations) {
+            if (operation === "read") {
+                DEFAULT_READ_OPERATIONS.forEach((op) => expandedOperations.add(op));
+            }
+            else if (operation === "write") {
+                DEFAULT_WRITE_OPERATIONS.forEach((op) => expandedOperations.add(op));
+            }
+            else {
+                expandedOperations.add(operation);
+            }
+        }
+        return Array.from(expandedOperations);
+    }
+    _getOperationNames(object) {
+        const directive = object.getDirective("model");
+        if (!directive) {
+            throw new TransformerPluginExecutionError(this.name, `@model directive not found for type ${object.name}`);
+        }
+        const args = directive.getArgumentsJSON();
+        if (args.operations && args.operations.length > 0) {
+            return this._expandOperations(args.operations);
+        }
+        return this._defaultOperations;
+    }
+    _createGetQuery(model) {
+        const fieldName = camelCase("get", model.name);
+        const queryNode = this.context.document.getQueryNode();
+        // We allow users to implement custom definition for fields.
+        // So, if the field already exists, we skip creating it.
+        if (!queryNode.hasField(fieldName)) {
+            const field = FieldNode.create(fieldName, NamedTypeNode.create(model.name), [InputValueNode.create("id", NonNullTypeNode.create("ID"))], [DirectiveNode.create("hasOne")]);
+            queryNode.addField(field);
+        }
+    }
+    _createListQuery(model) {
+        const fieldName = camelCase("list", pluralize(model.name));
+        const queryNode = this.context.document.getQueryNode();
+        if (!queryNode.hasField(fieldName)) {
+            const field = FieldNode.create(fieldName, NamedTypeNode.create(model.name), null, [
+                DirectiveNode.create("hasMany"),
+            ]);
+            queryNode.addField(field);
+        }
+    }
+    _shouldSkipFieldFromMutationInput(field) {
+        return (field.hasDirective("readOnly") ||
+            field.hasDirective("serverOnly") ||
+            field.hasDirective("clientOnly") ||
+            field.hasDirective("hasOne") ||
+            field.hasDirective("hasMany"));
+    }
+    _isBuildInScalarType(typeName) {
+        return ["ID", "String", "Int", "Float", "Boolean"].includes(typeName);
+    }
+    /**
+     * For each field in the model
+     * 1. If has `@readOnly` or connection directives - skip
+     * 2. If scalar or enum - add to input;
+     * 3. If union - skip;
+     * 4. If object or interface - check definition;
+     *    4.1 If `@model` - skip;
+     *    4.2 If implements `Node` interface - skip
+     *    4.3 If fields are `@readOnly` - skip;
+     */
+    _createMutationInput(model, inputName, requiredFields = []) {
+        const input = InputObjectNode.create(inputName);
+        if (inputName.startsWith("Delete")) {
+            input.addField(InputValueNode.create("id", NonNullTypeNode.create(NamedTypeNode.create("ID"))));
+        }
+        else {
+            for (const field of model.fields ?? []) {
+                if (this._shouldSkipFieldFromMutationInput(field)) {
+                    continue;
+                }
+                const fieldTypeName = field.type.getTypeName();
+                if (requiredFields.includes(field.name)) {
+                    input.addField(InputValueNode.create(field.name, NonNullTypeNode.create(fieldTypeName)));
+                    continue;
+                }
+                // Buildin scalars
+                if (this._isBuildInScalarType(fieldTypeName)) {
+                    input.addField(InputValueNode.create(field.name, NamedTypeNode.create(fieldTypeName)));
+                    continue;
+                }
+                const typeDef = this.context.document.getNode(fieldTypeName);
+                if (!typeDef) {
+                    throw new TransformerPluginExecutionError(this.name, `Unknown type ${fieldTypeName}`);
+                }
+                if (typeDef instanceof ScalarNode || typeDef instanceof EnumNode) {
+                    input.addField(InputValueNode.create(field.name, NamedTypeNode.create(fieldTypeName)));
+                    continue;
+                }
+                if (typeDef instanceof ObjectNode) {
+                    if (typeDef.hasDirective("model") ||
+                        typeDef.hasDirective("readOnly") ||
+                        typeDef.hasDirective("serverOnly") ||
+                        typeDef.hasDirective("clientOnly") ||
+                        typeDef.hasInterface("Node")) {
+                        continue;
+                    }
+                    const inputName = pascalCase(fieldTypeName, "input");
+                    if (!this.context.document.hasNode(inputName)) {
+                        this._createMutationInput(typeDef, inputName);
+                    }
+                    input.addField(InputValueNode.create(field.name, NamedTypeNode.create(inputName)));
+                }
+            }
+        }
+        this.context.document.addNode(input);
+    }
+    _createDeleteMutationField(model, fieldName) {
+        const mutationNode = this.context.document.getMutationNode();
+        if (!mutationNode.hasField(fieldName)) {
+            const field = FieldNode.create(fieldName, NamedTypeNode.create(model.name), [
+                InputValueNode.create("id", NonNullTypeNode.create(NamedTypeNode.create("ID"))),
+            ]);
+            mutationNode.addField(field);
+        }
+    }
+    _createMutationField(model, fieldName, inputName, requiredFields) {
+        const mutationNode = this.context.document.getMutationNode();
+        if (!this.context.document.getNode(inputName)) {
+            this._createMutationInput(model, inputName, requiredFields);
+        }
+        if (!mutationNode.hasField(fieldName)) {
+            const field = FieldNode.create(fieldName, NamedTypeNode.create(model.name), [
+                InputValueNode.create("input", NonNullTypeNode.create(NamedTypeNode.create(inputName))),
+            ]);
+            mutationNode.addField(field);
+        }
+    }
+    _createMutation(model, verb) {
+        const fieldName = camelCase(verb, model.name);
+        const inputName = pascalCase(verb, model.name, "input");
+        if (verb === "delete") {
+            this._createDeleteMutationField(model, fieldName);
+        }
+        else if (verb === "update") {
+            this._createMutationField(model, fieldName, inputName, ["id"]);
+        }
+        else {
+            this._createMutationField(model, fieldName, inputName);
+        }
+    }
+    // #endregion Operations
+    init() {
+        this.context.base
+            .addNode(EnumNode.create("ModelOperation", Object.values(ModelOperation), [
+            DirectiveNode.create(InternalDirective.INTERNAL),
+        ]))
+            .addNode(DirectiveDefinitionNode.create("model", ["OBJECT"], [
+            InputValueNode.create("operations", ListTypeNode.create(NonNullTypeNode.create("ModelOperation"))),
+        ]));
+    }
+    match(definition) {
+        return isModel(definition);
+    }
+    execute(definition) {
+        // 1. Add operation fields
+        const operations = this._getOperationNames(definition);
+        for (const verb of operations) {
+            switch (verb) {
+                case "get":
+                    this._createGetQuery(definition);
+                    break;
+                case "list":
+                    this._createListQuery(definition);
+                    break;
+                case "create":
+                case "upsert":
+                case "update":
+                case "delete":
+                    this._createMutation(definition, verb);
+                    break;
+                default:
+                    continue;
+            }
+        }
+    }
+    cleanup(definition) {
+        definition.removeDirective(ModelDirective.MODEL);
+    }
+    after() {
+        this.context.document.removeNode(ModelDirective.MODEL).removeNode("ModelOperation");
+    }
+}
+export const modelPlugin = createPluginFactory(ModelPlugin);

package/dist/base/index.d.ts

@@ -0,0 +1,2 @@
+export { modelPlugin, isModel, ModelPlugin, type ModelPluginOptions, ModelOperation, ModelDirective, } from "./ModelPlugin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/base/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/base/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,OAAO,EACP,WAAW,EACX,KAAK,kBAAkB,EACvB,cAAc,EACd,cAAc,GACf,MAAM,kBAAkB,CAAC"}

package/dist/base/index.js

@@ -0,0 +1 @@
+export { modelPlugin, isModel, ModelPlugin, ModelOperation, ModelDirective, } from "./ModelPlugin.js";

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@gqlbase/plugins",
+  "version": "0.0.1",
+  "description": "Collection of plugins and presets for gqlbase, providing common transformations and utilities that can be used in GraphQL schema transformation processes.",
+  "sideEffects": false,
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "sls.dev",
+    "email": "dev@sls.dev",
+    "url": "https://wwww.sls.dev"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://www.sls.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slsdotdev/gqlbase.git",
+    "directory": "packages/plugins"
+  },
+  "bugs": {
+    "url": "https://github.com/slsdotdev/gqlbase/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "../../LICENSE"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./*": {
+      "default": "./dist/*/index.js",
+      "types": "./dist/*/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint 'src/**/*.{ts,tsx}' --fix",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@gqlbase/core": "*",
+    "@gqlbase/shared": "*"
+  },
+  "peerDependencies": {
+    "graphql": ">=16"
+  }
+}