fraiseql 2.2.1 → 2.9.0

package/dist/index.mjs

@@ -148,10 +148,12 @@ function extractFunctionSignature(_name, params, returnType) {
 
 // src/registry.ts
 var VALID_REST_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-function normaliseConfig(config2) {
+var VALID_INPUT_STYLES = /* @__PURE__ */ new Set(["flatten", "jsonb"]);
+var INJECT_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var INJECT_SOURCE_RE = /^jwt:[A-Za-z_][A-Za-z0-9_]*$/;
+function normaliseConfig(config, argNames) {
   const keyMap = {
     sqlSource: "sql_source",
-    sqlSourceDispatch: "sql_source_dispatch",
     autoParams: "auto_params",
     jsonbColumn: "jsonb_column",
     cacheTtlSeconds: "cache_ttl_seconds",
@@ -160,32 +162,65 @@ function normaliseConfig(config2) {
     relayCursorColumn: "relay_cursor_column",
     relayCursorType: "relay_cursor_type",
     requiresRole: "requires_role",
-    additionalViews: "additional_views"
+    additionalViews: "additional_views",
+    inputStyle: "input_style",
+    changelogPreImage: "changelog_pre_image"
   };
-  const hasRestPath = "restPath" in config2 && config2.restPath != null;
-  const hasRestMethod = "restMethod" in config2 && config2.restMethod != null;
+  const hasRestPath = "restPath" in config && config.restPath != null;
+  const hasRestMethod = "restMethod" in config && config.restMethod != null;
   if (hasRestMethod && !hasRestPath) {
     throw new Error("restMethod requires restPath to be set");
   }
   if (hasRestMethod) {
-    const method = String(config2.restMethod).toUpperCase();
+    const method = String(config.restMethod).toUpperCase();
     if (!VALID_REST_METHODS.has(method)) {
       throw new Error(
-        `Invalid REST method '${config2.restMethod}'. Must be one of: ${[...VALID_REST_METHODS].join(", ")}`
+        `Invalid REST method '${config.restMethod}'. Must be one of: ${[...VALID_REST_METHODS].join(", ")}`
+      );
+    }
+  }
+  if ("changelog" in config && typeof config.changelog !== "boolean") {
+    throw new Error(`changelog must be a boolean (got ${typeof config.changelog})`);
+  }
+  if ("changelogPreImage" in config && typeof config.changelogPreImage !== "boolean") {
+    throw new Error(
+      `changelogPreImage must be a boolean (got ${typeof config.changelogPreImage})`
+    );
+  }
+  if ("inputStyle" in config) {
+    if (typeof config.inputStyle !== "string") {
+      throw new Error(`inputStyle must be a string (got ${typeof config.inputStyle})`);
+    }
+    if (!VALID_INPUT_STYLES.has(config.inputStyle)) {
+      throw new Error(
+        `inputStyle must be one of ${[...VALID_INPUT_STYLES].join(", ")} (got '${config.inputStyle}')`
       );
     }
   }
   const result = {};
-  for (const [key, value] of Object.entries(config2)) {
+  for (const [key, value] of Object.entries(config)) {
     if (key === "restPath" || key === "restMethod") {
       continue;
     } else if (key === "inject" && value !== null && typeof value === "object") {
       const injected = {};
       for (const [param, spec] of Object.entries(value)) {
-        const colonIdx = spec.indexOf(":");
-        if (colonIdx > 0) {
-          injected[param] = { source: spec.slice(0, colonIdx), claim: spec.slice(colonIdx + 1) };
+        if (!INJECT_KEY_RE.test(param)) {
+          throw new Error(
+            `inject key '${param}' is not a valid identifier. Keys must start with a letter or underscore and contain only letters, digits, and underscores.`
+          );
+        }
+        if (argNames?.has(param)) {
+          throw new Error(
+            `inject key '${param}' conflicts with a declared GraphQL argument of the same name. Use a different parameter name.`
+          );
+        }
+        if (typeof spec !== "string" || !INJECT_SOURCE_RE.test(spec)) {
+          throw new Error(
+            `inject source '${String(spec)}' for param '${param}' is invalid. Supported format: 'jwt:<claim_name>' (e.g. 'jwt:org_id', 'jwt:sub').`
+          );
         }
+        const colonIdx = spec.indexOf(":");
+        injected[param] = { source: spec.slice(0, colonIdx), claim: spec.slice(colonIdx + 1) };
       }
       result["inject_params"] = injected;
     } else if (key === "deprecated" && typeof value === "string") {
@@ -195,9 +230,9 @@ function normaliseConfig(config2) {
     }
   }
   if (hasRestPath) {
-    const method = hasRestMethod ? String(config2.restMethod).toUpperCase() : void 0;
+    const method = hasRestMethod ? String(config.restMethod).toUpperCase() : void 0;
     result["rest"] = {
-      path: config2.restPath,
+      path: config.restPath,
       method
     };
   }
@@ -250,32 +285,32 @@ var SchemaRegistry = class {
    * @param description - Optional query description
    * @param config - Additional configuration (sql_source, etc.)
    */
-  static registerQuery(name, returnType, returnsList, nullable, args, description, config2) {
+  static registerQuery(name, returnType, returnsList, nullable, args, description, config) {
     if (this.queries.has(name)) {
       throw new Error(
         `Query '${name}' is already registered. Each name must be unique within a schema.`
       );
     }
     const cleanType = returnsList ? returnType.replace(/[[\]!]/g, "") : returnType;
-    if (config2?.relay) {
+    if (config?.relay) {
       if (!returnsList) {
         throw new Error(
           `registerQuery('${name}'): relay: true requires returns_list to be true. Relay connections only apply to list queries.`
         );
       }
-      if (!config2.sqlSource) {
+      if (!config.sqlSource) {
         throw new Error(
           `registerQuery('${name}'): relay: true requires sqlSource to be set. The compiler needs the view name to derive the cursor column.`
         );
       }
-      if (config2.autoParams) {
-        const ap = { ...config2.autoParams };
+      if (config.autoParams) {
+        const ap = { ...config.autoParams };
         delete ap["limit"];
         delete ap["offset"];
-        config2 = { ...config2, autoParams: ap };
+        config = { ...config, autoParams: ap };
       }
     }
-    const normalisedConfig = config2 ? normaliseConfig(config2) : void 0;
+    const normalisedConfig = config ? normaliseConfig(config, new Set(args.map((a) => a.name))) : void 0;
     if (normalisedConfig?.rest) {
       const rest = normalisedConfig.rest;
       if (!rest.method) {
@@ -303,14 +338,14 @@ var SchemaRegistry = class {
    * @param description - Optional mutation description
    * @param config - Additional configuration (sql_source, operation, etc.)
    */
-  static registerMutation(name, returnType, returnsList, nullable, args, description, config2) {
+  static registerMutation(name, returnType, returnsList, nullable, args, description, config) {
     if (this.mutations.has(name)) {
       throw new Error(
         `Mutation '${name}' is already registered. Each name must be unique within a schema.`
       );
     }
     const cleanType = returnsList ? returnType.replace(/[[\]!]/g, "") : returnType;
-    const normalisedConfig = config2 ? normaliseConfig(config2) : void 0;
+    const normalisedConfig = config ? normaliseConfig(config, new Set(args.map((a) => a.name))) : void 0;
     if (normalisedConfig?.rest) {
       const rest = normalisedConfig.rest;
       if (!rest.method) {
@@ -340,7 +375,7 @@ var SchemaRegistry = class {
    * @param description - Optional subscription description
    * @param config - Additional configuration (topic, operation, etc.)
    */
-  static registerSubscription(name, entityType, nullable, args, description, config2) {
+  static registerSubscription(name, entityType, nullable, args, description, config) {
     if (this.subscriptions.has(name)) {
       throw new Error(
         `Subscription '${name}' is already registered. Each name must be unique within a schema.`
@@ -352,7 +387,7 @@ var SchemaRegistry = class {
       nullable,
       arguments: args,
       description,
-      ...config2
+      ...config
     });
   }
   /**
@@ -649,11 +684,11 @@ function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
       nullable: f.nullable
     }));
     SchemaRegistry.registerInputType(inputName, inputFields, `Input for creating a new ${typeName}.`);
-    const config2 = {
+    const config = {
       sql_source: `fn_create_${snake}`,
       operation: "INSERT"
     };
-    if (cascade) config2.cascade = true;
+    if (cascade) config.cascade = true;
     SchemaRegistry.registerMutation(
       `create_${snake}`,
       typeName,
@@ -661,7 +696,7 @@ function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
       false,
       [{ name: "input", type: inputName, nullable: false }],
       `Create a new ${typeName}.`,
-      config2
+      config
     );
   }
   if (ops.has("update")) {
@@ -672,11 +707,11 @@ function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
       ...writableFields.map((f) => ({ name: f.name, type: f.type, nullable: true }))
     ];
     SchemaRegistry.registerInputType(inputName, inputFields, `Input for updating an existing ${typeName}.`);
-    const config2 = {
+    const config = {
       sql_source: `fn_update_${snake}`,
       operation: "UPDATE"
     };
-    if (cascade) config2.cascade = true;
+    if (cascade) config.cascade = true;
     SchemaRegistry.registerMutation(
       `update_${snake}`,
       typeName,
@@ -684,15 +719,15 @@ function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
       true,
       [{ name: "input", type: inputName, nullable: false }],
       `Update an existing ${typeName}.`,
-      config2
+      config
     );
   }
   if (ops.has("delete")) {
-    const config2 = {
+    const config = {
       sql_source: `fn_delete_${snake}`,
       operation: "DELETE"
     };
-    if (cascade) config2.cascade = true;
+    if (cascade) config.cascade = true;
     SchemaRegistry.registerMutation(
       `delete_${snake}`,
       typeName,
@@ -700,7 +735,7 @@ function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
       false,
       [{ name: pkField.name, type: pkField.type, nullable: false }],
       `Delete a ${typeName}.`,
-      config2
+      config
     );
   }
 }
@@ -718,7 +753,7 @@ function Type(_config) {
     return constructor;
   };
 }
-function Query(config2) {
+function Query(config) {
   return function(_target, propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     const methodName = propertyKey;
@@ -733,12 +768,12 @@ function Query(config2) {
       [],
       // Placeholder
       originalMethod?.toString?.().split("\n")[0] ?? void 0,
-      config2
+      config
     );
     return descriptor;
   };
 }
-function Mutation(config2) {
+function Mutation(config) {
   return function(_target, propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     const methodName = propertyKey;
@@ -753,28 +788,28 @@ function Mutation(config2) {
       [],
       // Placeholder
       originalMethod?.toString?.().split("\n")[0] ?? void 0,
-      config2
+      config
     );
     return descriptor;
   };
 }
-function enum_(name, values, config2) {
+function enum_(name, values, config) {
   const enumValues = Object.keys(values).map((key) => ({
     name: key
   }));
-  SchemaRegistry.registerEnum(name, enumValues, config2?.description);
+  SchemaRegistry.registerEnum(name, enumValues, config?.description);
   return values;
 }
-function interface_(name, fields, config2) {
-  SchemaRegistry.registerInterface(name, fields, config2?.description);
+function interface_(name, fields, config) {
+  SchemaRegistry.registerInterface(name, fields, config?.description);
   return {};
 }
-function union(name, memberTypes, config2) {
-  SchemaRegistry.registerUnion(name, memberTypes, config2?.description);
+function union(name, memberTypes, config) {
+  SchemaRegistry.registerUnion(name, memberTypes, config?.description);
   return {};
 }
-function input(name, fields, config2) {
-  SchemaRegistry.registerInputType(name, fields, config2?.description);
+function input(name, fields, config) {
+  SchemaRegistry.registerInputType(name, fields, config?.description);
   return {};
 }
 function registerTypeFields(typeName, fields, description, options) {
@@ -783,55 +818,10 @@ function registerTypeFields(typeName, fields, description, options) {
     generateCrudOperations(typeName, fields, options.crud, options.sqlSource, options.cascade);
   }
 }
-var SAFE_SQL_IDENT = /^[A-Za-z_][A-Za-z0-9_$]*$/;
-function registerQuery(name, returnTypeOrConfig, returnsList, nullable, args, description, config2) {
-  if (typeof returnTypeOrConfig === "object" && returnTypeOrConfig !== null) {
-    const cfg = returnTypeOrConfig;
-    const dispatch = cfg.sqlSourceDispatch;
-    if (dispatch !== void 0) {
-      if (cfg.sqlSource !== void 0) {
-        throw new Error(
-          `registerQuery('${name}'): sqlSource and sqlSourceDispatch are mutually exclusive.`
-        );
-      }
-      const dispatchArg = dispatch.argument;
-      const queryArgs = cfg.arguments ?? [];
-      const argDef = queryArgs.find((a) => a.name === dispatchArg);
-      if (argDef === void 0) {
-        throw new Error(
-          `registerQuery('${name}'): sqlSourceDispatch argument '${dispatchArg}' not found in arguments list.`
-        );
-      }
-      if (argDef.nullable) {
-        throw new Error(
-          `registerQuery('${name}'): sqlSourceDispatch argument '${dispatchArg}' must be non-nullable.`
-        );
-      }
-      if (dispatch.mapping !== void 0) {
-        for (const [key, value] of Object.entries(dispatch.mapping)) {
-          if (!SAFE_SQL_IDENT.test(value)) {
-            throw new Error(
-              `registerQuery('${name}'): sql_source_dispatch mapping value '${value}' for key '${key}' is not a safe SQL identifier.`
-            );
-          }
-        }
-      }
-    }
-    const { returnType, returnsList: rl, nullable: nl, arguments: qArgs, description: desc, ...rest } = cfg;
-    SchemaRegistry.registerQuery(
-      name,
-      returnType,
-      rl ?? false,
-      nl ?? false,
-      qArgs ?? [],
-      desc,
-      rest
-    );
-    return;
-  }
-  SchemaRegistry.registerQuery(name, returnTypeOrConfig, returnsList ?? false, nullable ?? false, args ?? [], description, config2);
+function registerQuery(name, returnType, returnsList, nullable, args, description, config) {
+  SchemaRegistry.registerQuery(name, returnType, returnsList, nullable, args, description, config);
 }
-function registerMutation(name, returnType, returnsList, nullable, args, description, config2) {
+function registerMutation(name, returnType, returnsList, nullable, args, description, config) {
   SchemaRegistry.registerMutation(
     name,
     returnType,
@@ -839,14 +829,14 @@ function registerMutation(name, returnType, returnsList, nullable, args, descrip
     nullable,
     args,
     description,
-    config2
+    config
   );
 }
-function Subscription(config2) {
+function Subscription(config) {
   return function(_target, propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     const methodName = propertyKey;
-    const entityType = config2?.entityType || "Subscription";
+    const entityType = config?.entityType || "Subscription";
     SchemaRegistry.registerSubscription(
       methodName,
       entityType,
@@ -855,13 +845,13 @@ function Subscription(config2) {
       [],
       // Placeholder for arguments
       originalMethod?.toString?.().split("\n")[0] ?? void 0,
-      config2
+      config
     );
     return descriptor;
   };
 }
-function registerSubscription(name, entityType, nullable, args, description, config2) {
-  SchemaRegistry.registerSubscription(name, entityType, nullable, args, description, config2);
+function registerSubscription(name, entityType, nullable, args, description, config) {
+  SchemaRegistry.registerSubscription(name, entityType, nullable, args, description, config);
 }
 function Scalar(target) {
   if (!isCustomScalarSubclass(target)) {
@@ -921,12 +911,6 @@ function validateSchemaBeforeExport(schema) {
     );
   }
 }
-var ConfigHolder = class {
-  static pendingConfig = null;
-};
-function config(configObj) {
-  ConfigHolder.pendingConfig = configObj;
-}
 function exportSchema(outputPath, options = {}) {
   const { pretty = true } = options;
   const schema = SchemaRegistry.getSchema();
@@ -1031,15 +1015,15 @@ var DEFAULT_RETRY_CONFIG = {
   initial_delay_ms: 100,
   max_delay_ms: 6e4
 };
-function Observer(config2) {
+function Observer(config) {
   return function(_target, propertyKey, _descriptor) {
     SchemaRegistry.registerObserver(
       propertyKey,
-      config2.entity,
-      config2.event,
-      config2.actions,
-      config2.condition,
-      config2.retry
+      config.entity,
+      config.event,
+      config.actions,
+      config.condition,
+      config.retry
     );
   };
 }
@@ -1132,7 +1116,7 @@ var RateLimitError = class extends FraiseQLError {
 };
 
 // src/http-retry.ts
-async function executeWithRetry(fn, config2 = {}) {
+async function executeWithRetry(fn, config = {}) {
   const {
     maxAttempts = 1,
     baseDelayMs = 1e3,
@@ -1140,7 +1124,7 @@ async function executeWithRetry(fn, config2 = {}) {
     jitter = true,
     retryOn = [NetworkError, TimeoutError],
     onRetry
-  } = config2;
+  } = config;
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
@@ -1173,13 +1157,13 @@ var FraiseQLClient = class {
   extraHeaders;
   fetchFn;
   constructor(urlOrConfig) {
-    const config2 = typeof urlOrConfig === "string" ? { url: urlOrConfig } : urlOrConfig;
-    this.url = config2.url;
-    this.authorization = config2.authorization;
-    this.timeoutMs = config2.timeoutMs ?? 3e4;
-    this.retry = config2.retry ?? {};
-    this.extraHeaders = config2.headers ?? {};
-    this.fetchFn = config2.fetch ?? globalThis.fetch.bind(globalThis);
+    const config = typeof urlOrConfig === "string" ? { url: urlOrConfig } : urlOrConfig;
+    this.url = config.url;
+    this.authorization = config.authorization;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.retry = config.retry ?? {};
+    this.extraHeaders = config.headers ?? {};
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
   }
   async resolveAuth() {
     if (this.authorization === void 0) return void 0;
@@ -1268,7 +1252,7 @@ var FraiseQLClient = class {
 };
 
 // src/index.ts
-var version = "2.0.0-alpha.1";
+var version = "2.9.0";
 export {
   AuthenticationError,
   CustomScalar,
@@ -1288,7 +1272,6 @@ export {
   Subscription,
   TimeoutError,
   Type,
-  config,
   email,
   enum_,
   executeWithRetry,

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "fraiseql",
-  "version": "2.2.1",
+  "version": "2.9.0",
   "description": "FraiseQL v2 - Compiled GraphQL execution engine (schema authoring + HTTP client)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fraiseql/fraiseql.git",
+    "directory": "sdks/official/fraiseql-typescript"
+  },
+  "homepage": "https://fraiseql.dev",
+  "bugs": "https://github.com/fraiseql/fraiseql/issues",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -46,9 +53,9 @@
     "zod": "^3.22.0"
   },
   "peerDependencies": {
-    "ai": "^3.0.0",
-    "@langchain/core": "^0.1.0",
-    "@mastra/core": "^0.1.0"
+    "@langchain/core": "^1.1.47",
+    "@mastra/core": "^1.35.0",
+    "ai": "^6.0.185"
   },
   "peerDependenciesMeta": {
     "ai": {
@@ -62,19 +69,19 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@langchain/core": "^1.1.47",
+    "@mastra/core": "^1.35.0",
+    "@types/node": "^25.9.1",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "ai": "^4.0.0",
-    "@langchain/core": "^0.3.0",
-    "@mastra/core": "^0.9.0",
-    "eslint": "^9.0.0",
+    "ai": "^6.0.185",
+    "eslint": "^10.4.0",
     "msw": "^2.0.0",
     "prettier": "^3.0.0",
     "tsup": "^8.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.3.0",
-    "vitest": "^2.0.0"
+    "vitest": "^4.1.6"
   },
   "engines": {
     "node": ">=18.0.0"