@cedarjs/gqlorm 3.0.0-canary.13429

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+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

@@ -0,0 +1,3 @@
+# gqlorm
+
+Prisma inspired GraphQL query builder

package/dist/cjs/generator/graphqlGenerator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GraphQL query generator that converts AST to GraphQL query strings
+ * Transforms our internal AST representation into valid GraphQL queries
+ */
+import type { QueryAST } from '../types/ast.js';
+import { type ModelSchema } from '../types/schema.js';
+export declare class GraphQLGenerateError extends Error {
+    context?: any | undefined;
+    constructor(message: string, context?: any | undefined);
+}
+export interface GraphQLQuery {
+    query: string;
+    variables?: Record<string, any>;
+}
+export declare class GraphQLGenerator {
+    #private;
+    constructor(schema?: ModelSchema);
+    /**
+     * Generate GraphQL query from AST
+     */
+    generate(ast: QueryAST): GraphQLQuery;
+}
+export declare const graphqlGenerator: GraphQLGenerator;
+//# sourceMappingURL=graphqlGenerator.d.ts.map

package/dist/cjs/generator/graphqlGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlGenerator.d.ts","sourceRoot":"","sources":["../../../src/generator/graphqlGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAOV,QAAQ,EAKT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAOrD,qBAAa,oBAAqB,SAAQ,KAAK;IAGpC,OAAO,CAAC,EAAE,GAAG;gBADpB,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,GAAG,YAAA;CAKvB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAChC;AAED,qBAAa,gBAAgB;;gBASf,MAAM,CAAC,EAAE,WAAW;IAIhC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,YAAY;CAodtC;AAGD,eAAO,MAAM,gBAAgB,kBAAyB,CAAA"}

package/dist/cjs/generator/graphqlGenerator.js

@@ -0,0 +1,421 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphqlGenerator_exports = {};
+__export(graphqlGenerator_exports, {
+  GraphQLGenerateError: () => GraphQLGenerateError,
+  GraphQLGenerator: () => GraphQLGenerator,
+  graphqlGenerator: () => graphqlGenerator
+});
+module.exports = __toCommonJS(graphqlGenerator_exports);
+var import_typeUtils = require("../types/typeUtils.js");
+class GraphQLGenerateError extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "GraphQLGenerateError";
+  }
+}
+class GraphQLGenerator {
+  #variableCounter = 0;
+  #variables = {};
+  // Track field names for each variable
+  #variableFields = /* @__PURE__ */ new Map();
+  // Track current operation for context-aware type generation
+  #operation;
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  /**
+   * Generate GraphQL query from AST
+   */
+  generate(ast) {
+    this.#resetState();
+    this.#operation = ast.operation;
+    const operationName = this.#generateOperationName(ast);
+    const queryBody = this.#generateQueryBody(ast);
+    let query = `query ${operationName}`;
+    const hasVariables = Object.keys(this.#variables).length > 0;
+    if (hasVariables) {
+      const variableDefinitions = this.#generateVariableDefinitions();
+      query += `(${variableDefinitions})`;
+    }
+    query += ` {
+${queryBody}
+}`;
+    const result = { query };
+    if (hasVariables) {
+      result.variables = structuredClone(this.#variables);
+    }
+    return result;
+  }
+  /**
+   * Reset internal state for new query generation
+   */
+  #resetState() {
+    this.#variableCounter = 0;
+    this.#variables = {};
+    this.#variableFields.clear();
+    this.#operation = void 0;
+  }
+  /**
+   * Generate operation name
+   */
+  #generateOperationName(ast) {
+    const { model, operation } = ast;
+    return `${operation}${this.#capitalize(model)}`;
+  }
+  /**
+   * Generate main query body
+   */
+  #generateQueryBody(ast) {
+    const { model, operation, args, isLive } = ast;
+    const fieldName = this.#getGraphQLFieldName(model, operation);
+    let query = `  ${fieldName}`;
+    if (args) {
+      const argsString = this.#generateArguments(args, operation);
+      if (argsString) {
+        query += `(${argsString})`;
+      }
+    }
+    if (isLive) {
+      query += " @live";
+    }
+    const fields = this.#generateFieldSelection(args, model);
+    query += ` {
+${fields}
+  }`;
+    return query;
+  }
+  /**
+   * Convert operation to GraphQL field name
+   */
+  #getGraphQLFieldName(model, operation) {
+    switch (operation) {
+      case "findMany":
+        return `${model}s`;
+      case "findUnique":
+      case "findUniqueOrThrow":
+        return model;
+      case "findFirst":
+      case "findFirstOrThrow":
+        return model;
+      default:
+        throw new GraphQLGenerateError(`Unsupported operation: ${operation}`);
+    }
+  }
+  /**
+   * Generate GraphQL arguments from query args
+   */
+  #generateArguments(args, operation) {
+    const argParts = [];
+    if (args?.where) {
+      const isFindUnique = operation === "findUnique" || operation === "findUniqueOrThrow";
+      const simpleUniqueArg = isFindUnique ? this.#extractSimpleUniqueArgument(args.where) : null;
+      if (simpleUniqueArg) {
+        argParts.push(simpleUniqueArg);
+      } else {
+        const whereArg = this.#generateWhereArgument(args.where);
+        if (whereArg && whereArg !== "{}") {
+          argParts.push(`where: ${whereArg}`);
+        }
+      }
+    }
+    if (args?.orderBy) {
+      const orderByArg = this.#generateOrderByArgument(args.orderBy);
+      argParts.push(`orderBy: ${orderByArg}`);
+    }
+    if (typeof args?.take === "number") {
+      argParts.push(`first: ${args.take}`);
+    }
+    if (typeof args?.skip === "number") {
+      argParts.push(`skip: ${args.skip}`);
+    }
+    return argParts.join(", ");
+  }
+  /**
+   * Extract simple unique argument for findUnique operations
+   * Returns direct argument format (e.g., "id: $var0") if the where clause
+   * contains a single simple field equality, otherwise returns null
+   */
+  #extractSimpleUniqueArgument(where) {
+    if (where.conditions.length !== 1) {
+      return null;
+    }
+    const condition = where.conditions[0];
+    if (!(0, import_typeUtils.isFieldCondition)(condition) || condition.operator !== "equals") {
+      return null;
+    }
+    const variableName = this.#addVariable(condition.value, condition.field);
+    return `${condition.field}: $${variableName}`;
+  }
+  /**
+   * Generate variable definitions for GraphQL query
+   */
+  #generateVariableDefinitions() {
+    return Object.entries(this.#variables).map(([name, value]) => {
+      const fieldName = this.#variableFields.get(name);
+      const baseType = this.#getGraphQLType(value, fieldName);
+      const isFindUnique = this.#operation === "findUnique" || this.#operation === "findUniqueOrThrow";
+      const isIdField = fieldName === "id" || fieldName?.endsWith("Id");
+      if (isFindUnique && isIdField && !baseType.includes("!")) {
+        return `$${name}: ${baseType}!`;
+      }
+      return `$${name}: ${baseType}`;
+    }).join(", ");
+  }
+  /**
+   * Generate WHERE argument
+   */
+  #generateWhereArgument(where) {
+    const conditions = where.conditions.map(
+      (condition) => this.#generateCondition(condition)
+    );
+    if (conditions.length === 0) {
+      return "{}";
+    }
+    if (conditions.length === 1) {
+      return conditions[0];
+    }
+    return `{ AND: [${conditions.join(", ")}] }`;
+  }
+  /**
+   * Generate individual where condition
+   */
+  #generateCondition(condition) {
+    if ((0, import_typeUtils.isFieldCondition)(condition)) {
+      return this.#generateFieldCondition(condition);
+    } else if ((0, import_typeUtils.isLogicalCondition)(condition)) {
+      return this.#generateLogicalCondition(condition);
+    } else if ((0, import_typeUtils.isRelationCondition)(condition)) {
+      return this.#generateRelationCondition(condition);
+    }
+    throw new GraphQLGenerateError("Unknown condition type", { condition });
+  }
+  /**
+   * Generate field condition
+   */
+  #generateFieldCondition(condition) {
+    const { field, operator, value } = condition;
+    if (operator === "equals") {
+      const variableName2 = this.#addVariable(value, field);
+      return `{ ${field}: $${variableName2} }`;
+    }
+    const operatorMap = {
+      equals: "equals",
+      not: "not",
+      in: "in",
+      notIn: "notIn",
+      lt: "lt",
+      lte: "lte",
+      gt: "gt",
+      gte: "gte",
+      contains: "contains",
+      startsWith: "startsWith",
+      endsWith: "endsWith",
+      isNull: "isNull",
+      isNotNull: "isNotNull"
+    };
+    const gqlOperator = operatorMap[operator];
+    if (!gqlOperator) {
+      throw new GraphQLGenerateError(`Unsupported operator: ${operator}`);
+    }
+    if (operator === "isNull" || operator === "isNotNull") {
+      return `{ ${field}: { ${gqlOperator}: ${operator === "isNull"} } }`;
+    }
+    const variableName = this.#addVariable(value, field);
+    return `{ ${field}: { ${gqlOperator}: $${variableName} } }`;
+  }
+  /**
+   * Generate logical condition
+   */
+  #generateLogicalCondition(condition) {
+    const { operator, conditions } = condition;
+    const conditionStrings = conditions.map(
+      (cond) => this.#generateCondition(cond)
+    );
+    if (operator === "NOT") {
+      if (conditionStrings.length !== 1) {
+        throw new GraphQLGenerateError(
+          "NOT operator must have exactly one condition"
+        );
+      }
+      return `{ NOT: ${conditionStrings[0]} }`;
+    }
+    return `{ ${operator}: [${conditionStrings.join(", ")}] }`;
+  }
+  /**
+   * Generate relation condition
+   */
+  #generateRelationCondition(condition) {
+    const { relation, condition: nestedCondition } = condition;
+    const whereArg = this.#generateWhereArgument(nestedCondition);
+    return `{ ${relation}: ${whereArg} }`;
+  }
+  /**
+   * Generate ORDER BY argument
+   */
+  #generateOrderByArgument(orderBy) {
+    const fields = orderBy.fields.map((field) => {
+      const direction = field.direction.toUpperCase();
+      return `{ ${field.field}: ${direction} }`;
+    });
+    if (fields.length === 1) {
+      return fields[0];
+    }
+    return `[${fields.join(", ")}]`;
+  }
+  /**
+   * Generate field selection
+   */
+  #generateFieldSelection(args, model) {
+    if (args?.select) {
+      return this.#generateSelectFields(args.select);
+    }
+    if (args?.include) {
+      return this.#generateIncludeFields(args.include);
+    }
+    if (model && this.#schema && this.#schema[model]) {
+      const fields = this.#schema[model];
+      return fields.map((field) => `    ${field}`).join("\n");
+    }
+    return "    id\n    createdAt\n    updatedAt";
+  }
+  /**
+   * Generate fields from SELECT clause
+   */
+  #generateSelectFields(select) {
+    const fieldStrings = [];
+    for (const fieldSelection of select.fields) {
+      if (!fieldSelection.selected) {
+        continue;
+      }
+      if (fieldSelection.nested) {
+        const nestedFields = fieldSelection.nested.type === "Select" ? this.#generateSelectFields(fieldSelection.nested) : this.#generateIncludeFields(fieldSelection.nested);
+        const indentedFields = this.#indent(nestedFields, 2);
+        fieldStrings.push(
+          `    ${fieldSelection.field} {
+${indentedFields}
+    }`
+        );
+      } else {
+        fieldStrings.push(`    ${fieldSelection.field}`);
+      }
+    }
+    return fieldStrings.join("\n");
+  }
+  /**
+   * Generate fields from INCLUDE clause
+   */
+  #generateIncludeFields(include) {
+    const fieldStrings = [];
+    fieldStrings.push("    id");
+    for (const relationInclusion of include.relations) {
+      if (!relationInclusion.included) {
+        continue;
+      }
+      let relationQuery = `    ${relationInclusion.relation}`;
+      if (relationInclusion.args) {
+        const argsString = this.#generateArguments(relationInclusion.args);
+        if (argsString) {
+          relationQuery += `(${argsString})`;
+        }
+      }
+      let nestedFields;
+      if (relationInclusion.nested) {
+        nestedFields = this.#generateIncludeFields(relationInclusion.nested);
+      } else if (relationInclusion.args?.select) {
+        nestedFields = this.#generateSelectFields(relationInclusion.args.select);
+      } else {
+        nestedFields = "      id";
+      }
+      relationQuery += ` {
+${this.#indent(nestedFields, 2)}
+    }`;
+      fieldStrings.push(relationQuery);
+    }
+    return fieldStrings.join("\n");
+  }
+  /**
+   * Add variable and return variable name
+   */
+  #addVariable(value, fieldName) {
+    const variableName = `var${this.#variableCounter++}`;
+    this.#variables[variableName] = value;
+    if (fieldName) {
+      this.#variableFields.set(variableName, fieldName);
+    }
+    return variableName;
+  }
+  /**
+   * Get GraphQL type for a value
+   */
+  #getGraphQLType(value, fieldName) {
+    const isIdField = fieldName && /^(id|.*Id|.*ID)$/.test(fieldName);
+    if (value === void 0 || value === null) {
+      return isIdField ? "ID" : "String";
+    }
+    if (typeof value === "string") {
+      return isIdField ? "ID" : "String";
+    }
+    if (typeof value === "number") {
+      if (isIdField) {
+        return "ID";
+      }
+      return Number.isInteger(value) ? "Int" : "Float";
+    }
+    if (typeof value === "boolean") {
+      return "Boolean";
+    }
+    if (value instanceof Date) {
+      return "DateTime";
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return "[String]";
+      }
+      const itemType = this.#getGraphQLType(value[0], fieldName);
+      if (isIdField && (itemType === "ID" || itemType === "String")) {
+        return `[ID!]`;
+      }
+      return `[${itemType}]`;
+    }
+    return "String";
+  }
+  /**
+   * Capitalize first letter of string
+   */
+  #capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  /**
+   * Indent text by specified number of levels
+   */
+  #indent(text, levels) {
+    const indentation = "  ".repeat(levels);
+    return text.split("\n").map((line) => line.trim() ? `${indentation}${line}` : line).join("\n");
+  }
+}
+const graphqlGenerator = new GraphQLGenerator();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GraphQLGenerateError,
+  GraphQLGenerator,
+  graphqlGenerator
+});