fraiseql 2.1.1

package/dist/index.mjs

@@ -0,0 +1,1265 @@
+// src/scalars.ts
+var CustomScalar = class {
+};
+var SCALAR_NAMES = /* @__PURE__ */ new Set([
+  // Core
+  "ID",
+  "UUID",
+  "Json",
+  "Decimal",
+  "Vector",
+  // Date/Time
+  "DateTime",
+  "Date",
+  "Time",
+  "DateRange",
+  "Duration",
+  // Contact/Communication
+  "Email",
+  "PhoneNumber",
+  "URL",
+  "DomainName",
+  "Hostname",
+  // Location/Address
+  "PostalCode",
+  "Latitude",
+  "Longitude",
+  "Coordinates",
+  "Timezone",
+  "LocaleCode",
+  "LanguageCode",
+  "CountryCode",
+  // Financial
+  "IBAN",
+  "CUSIP",
+  "ISIN",
+  "SEDOL",
+  "LEI",
+  "MIC",
+  "CurrencyCode",
+  "Money",
+  "ExchangeCode",
+  "ExchangeRate",
+  "StockSymbol",
+  "Percentage",
+  // Identifiers
+  "Slug",
+  "SemanticVersion",
+  "HashSHA256",
+  "APIKey",
+  "LicensePlate",
+  "VIN",
+  "TrackingNumber",
+  "ContainerNumber",
+  // Networking
+  "IPAddress",
+  "IPv4",
+  "IPv6",
+  "MACAddress",
+  "CIDR",
+  "Port",
+  // Transportation
+  "AirportCode",
+  "PortCode",
+  "FlightNumber",
+  // Content
+  "Markdown",
+  "HTML",
+  "MimeType",
+  "Color",
+  "Image",
+  "File",
+  // Database
+  "LTree"
+]);
+function isScalarType(typeName) {
+  return SCALAR_NAMES.has(typeName);
+}
+
+// src/types.ts
+function typeToGraphQL(type) {
+  if (type === null || type === void 0) {
+    throw new Error("Cannot convert null or undefined type");
+  }
+  const typeStr = String(type);
+  if (type === String || typeStr === "String") {
+    return ["String", false];
+  }
+  if (type === Number || typeStr === "Number") {
+    return ["Float", false];
+  }
+  if (type === Boolean || typeStr === "Boolean") {
+    return ["Boolean", false];
+  }
+  if (typeof type === "function") {
+    return [type.name || "Object", false];
+  }
+  if (typeof type === "string") {
+    if (type.includes(" | null")) {
+      const baseType = type.replace(" | null", "").trim();
+      return [baseType, true];
+    }
+    if (type.endsWith("[]")) {
+      const elementType = type.slice(0, -2);
+      return [`[${elementType}!]`, false];
+    }
+    if (isScalarType(type)) {
+      return [type, false];
+    }
+    return [type, false];
+  }
+  throw new Error(`Unsupported type: ${type}`);
+}
+function extractFieldInfo(fields) {
+  const result = {};
+  for (const [fieldName, fieldType] of Object.entries(fields)) {
+    const [graphqlType, nullable] = typeToGraphQL(fieldType);
+    result[fieldName] = {
+      type: graphqlType,
+      nullable
+    };
+  }
+  return result;
+}
+function extractFunctionSignature(_name, params, returnType) {
+  const args = [];
+  for (const [paramName, paramType] of Object.entries(params)) {
+    if (paramName === "self" || paramName === "info") {
+      continue;
+    }
+    const [graphqlType, nullable] = typeToGraphQL(paramType);
+    args.push({
+      name: paramName,
+      type: graphqlType,
+      nullable
+    });
+  }
+  const [returnTypeStr, returnNullable] = typeToGraphQL(returnType);
+  const isList = returnTypeStr.startsWith("[") && returnTypeStr.endsWith("]");
+  return {
+    arguments: args,
+    returnType: {
+      type: returnTypeStr,
+      nullable: returnNullable,
+      isList
+    }
+  };
+}
+
+// src/registry.ts
+var VALID_REST_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+function normaliseConfig(config2) {
+  const keyMap = {
+    sqlSource: "sql_source",
+    autoParams: "auto_params",
+    jsonbColumn: "jsonb_column",
+    cacheTtlSeconds: "cache_ttl_seconds",
+    invalidatesViews: "invalidates_views",
+    invalidatesFactTables: "invalidates_fact_tables",
+    relayCursorColumn: "relay_cursor_column",
+    relayCursorType: "relay_cursor_type",
+    requiresRole: "requires_role",
+    additionalViews: "additional_views"
+  };
+  const hasRestPath = "restPath" in config2 && config2.restPath != null;
+  const hasRestMethod = "restMethod" in config2 && config2.restMethod != null;
+  if (hasRestMethod && !hasRestPath) {
+    throw new Error("restMethod requires restPath to be set");
+  }
+  if (hasRestMethod) {
+    const method = String(config2.restMethod).toUpperCase();
+    if (!VALID_REST_METHODS.has(method)) {
+      throw new Error(
+        `Invalid REST method '${config2.restMethod}'. Must be one of: ${[...VALID_REST_METHODS].join(", ")}`
+      );
+    }
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(config2)) {
+    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) };
+        }
+      }
+      result["inject_params"] = injected;
+    } else if (key === "deprecated" && typeof value === "string") {
+      result["deprecation"] = { reason: value };
+    } else {
+      result[keyMap[key] ?? key] = value;
+    }
+  }
+  if (hasRestPath) {
+    const method = hasRestMethod ? String(config2.restMethod).toUpperCase() : void 0;
+    result["rest"] = {
+      path: config2.restPath,
+      method
+    };
+  }
+  return result;
+}
+var SchemaRegistry = class {
+  static types = /* @__PURE__ */ new Map();
+  static queries = /* @__PURE__ */ new Map();
+  static mutations = /* @__PURE__ */ new Map();
+  static subscriptions = /* @__PURE__ */ new Map();
+  static enums = /* @__PURE__ */ new Map();
+  static interfaces = /* @__PURE__ */ new Map();
+  static inputTypes = /* @__PURE__ */ new Map();
+  static unions = /* @__PURE__ */ new Map();
+  static factTables = /* @__PURE__ */ new Map();
+  static aggregateQueries = /* @__PURE__ */ new Map();
+  static observers = /* @__PURE__ */ new Map();
+  static customScalars = /* @__PURE__ */ new Map();
+  /**
+   * Register a GraphQL type.
+   *
+   * @param name - Type name (e.g., "User")
+   * @param fields - List of field definitions
+   * @param description - Optional type description
+   * @param options - Additional type options
+   */
+  static registerType(name, fields, description, options) {
+    if (this.types.has(name)) {
+      throw new Error(
+        `Type '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    const typeDef = { name, fields, description };
+    if (options?.relay) typeDef.relay = true;
+    if (options?.sqlSource) typeDef.sql_source = options.sqlSource;
+    if (options?.jsonbColumn) typeDef.jsonb_column = options.jsonbColumn;
+    if (options?.isError) typeDef.is_error = true;
+    if (options?.requiresRole) typeDef.requires_role = options.requiresRole;
+    if (options?.implements) typeDef.implements = options.implements;
+    this.types.set(name, typeDef);
+  }
+  /**
+   * Register a GraphQL query.
+   *
+   * @param name - Query name
+   * @param returnType - Return type name
+   * @param returnsList - Whether query returns a list
+   * @param nullable - Whether result can be null
+   * @param args - List of argument definitions
+   * @param description - Optional query description
+   * @param config - Additional configuration (sql_source, etc.)
+   */
+  static registerQuery(name, returnType, returnsList, nullable, args, description, config2) {
+    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 (!returnsList) {
+        throw new Error(
+          `registerQuery('${name}'): relay: true requires returns_list to be true. Relay connections only apply to list queries.`
+        );
+      }
+      if (!config2.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 };
+        delete ap["limit"];
+        delete ap["offset"];
+        config2 = { ...config2, autoParams: ap };
+      }
+    }
+    const normalisedConfig = config2 ? normaliseConfig(config2) : void 0;
+    if (normalisedConfig?.rest) {
+      const rest = normalisedConfig.rest;
+      if (!rest.method) {
+        rest.method = "GET";
+      }
+    }
+    this.queries.set(name, {
+      name,
+      return_type: cleanType,
+      returns_list: returnsList,
+      nullable,
+      arguments: args,
+      description,
+      ...normalisedConfig
+    });
+  }
+  /**
+   * Register a GraphQL mutation.
+   *
+   * @param name - Mutation name
+   * @param returnType - Return type name
+   * @param returnsList - Whether mutation returns a list
+   * @param nullable - Whether result can be null
+   * @param args - List of argument definitions
+   * @param description - Optional mutation description
+   * @param config - Additional configuration (sql_source, operation, etc.)
+   */
+  static registerMutation(name, returnType, returnsList, nullable, args, description, config2) {
+    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;
+    if (normalisedConfig?.rest) {
+      const rest = normalisedConfig.rest;
+      if (!rest.method) {
+        rest.method = "POST";
+      }
+    }
+    this.mutations.set(name, {
+      name,
+      return_type: cleanType,
+      returns_list: returnsList,
+      nullable,
+      arguments: args,
+      description,
+      ...normalisedConfig
+    });
+  }
+  /**
+   * Register a GraphQL subscription.
+   *
+   * Subscriptions in FraiseQL are compiled projections of database events.
+   * They are sourced from LISTEN/NOTIFY or CDC, not resolver-based.
+   *
+   * @param name - Subscription name
+   * @param entityType - Entity type name being subscribed to
+   * @param nullable - Whether result can be null
+   * @param args - List of argument definitions (filters)
+   * @param description - Optional subscription description
+   * @param config - Additional configuration (topic, operation, etc.)
+   */
+  static registerSubscription(name, entityType, nullable, args, description, config2) {
+    if (this.subscriptions.has(name)) {
+      throw new Error(
+        `Subscription '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.subscriptions.set(name, {
+      name,
+      entity_type: entityType,
+      nullable,
+      arguments: args,
+      description,
+      ...config2
+    });
+  }
+  /**
+   * Register a fact table definition.
+   *
+   * @param tableName - Fact table name
+   * @param measures - List of measure definitions
+   * @param dimensions - Dimension metadata
+   * @param denormalizedFilters - List of denormalized filter definitions
+   */
+  static registerFactTable(tableName, measures, dimensions, denormalizedFilters) {
+    this.factTables.set(tableName, {
+      table_name: tableName,
+      measures,
+      dimensions,
+      denormalized_filters: denormalizedFilters
+    });
+  }
+  /**
+   * Register an aggregate query definition.
+   *
+   * @param name - Query name
+   * @param factTable - Fact table name
+   * @param autoGroupBy - Auto-generate groupBy fields
+   * @param autoAggregates - Auto-generate aggregate fields
+   * @param description - Optional query description
+   */
+  static registerAggregateQuery(name, factTable, autoGroupBy, autoAggregates, description) {
+    this.aggregateQueries.set(name, {
+      name,
+      fact_table: factTable,
+      auto_group_by: autoGroupBy,
+      auto_aggregates: autoAggregates,
+      description
+    });
+  }
+  /**
+   * Register an observer.
+   *
+   * @param name - Observer function name
+   * @param entity - Entity type to observe
+   * @param event - Event type (INSERT, UPDATE, or DELETE)
+   * @param actions - List of action configurations
+   * @param condition - Optional condition expression
+   * @param retry - Retry configuration
+   */
+  static registerObserver(name, entity, event, actions, condition, retry) {
+    this.observers.set(name, {
+      name,
+      entity,
+      event: event.toUpperCase(),
+      actions,
+      condition,
+      retry: retry || {
+        max_attempts: 3,
+        backoff_strategy: "exponential",
+        initial_delay_ms: 100,
+        max_delay_ms: 6e4
+      }
+    });
+  }
+  /**
+   * Register a GraphQL enum type.
+   *
+   * @param name - Enum name (e.g., "OrderStatus")
+   * @param values - List of enum value definitions
+   * @param description - Optional enum description
+   */
+  static registerEnum(name, values, description) {
+    if (this.enums.has(name)) {
+      throw new Error(
+        `Enum '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.enums.set(name, {
+      name,
+      values,
+      description
+    });
+  }
+  /**
+   * Register a GraphQL interface type.
+   *
+   * @param name - Interface name (e.g., "Node")
+   * @param fields - List of field definitions
+   * @param description - Optional interface description
+   */
+  static registerInterface(name, fields, description) {
+    if (this.interfaces.has(name)) {
+      throw new Error(
+        `Interface '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.interfaces.set(name, {
+      name,
+      fields,
+      description
+    });
+  }
+  /**
+   * Register a GraphQL input type.
+   *
+   * @param name - Input type name (e.g., "CreateUserInput")
+   * @param fields - List of field definitions with optional defaults
+   * @param description - Optional input type description
+   */
+  static registerInputType(name, fields, description) {
+    if (this.inputTypes.has(name)) {
+      throw new Error(
+        `Input type '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.inputTypes.set(name, {
+      name,
+      fields,
+      description
+    });
+  }
+  /**
+   * Register a GraphQL union type.
+   *
+   * @param name - Union name (e.g., "SearchResult")
+   * @param memberTypes - List of member type names
+   * @param description - Optional union description
+   */
+  static registerUnion(name, memberTypes, description) {
+    if (this.unions.has(name)) {
+      throw new Error(
+        `Union '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.unions.set(name, {
+      name,
+      member_types: memberTypes,
+      description
+    });
+  }
+  /**
+   * Register a custom scalar.
+   *
+   * @param name - Scalar name (e.g., "Email")
+   * @param scalarClass - The CustomScalar subclass
+   * @param description - Optional scalar description
+   *
+   * @throws If scalar name is not unique
+   */
+  static registerScalar(name, scalarClass, description) {
+    if (this.customScalars.has(name)) {
+      throw new Error(
+        `Scalar '${name}' is already registered. Each name must be unique within a schema.`
+      );
+    }
+    this.customScalars.set(name, { class: scalarClass, description });
+  }
+  /**
+   * Get all registered custom scalars.
+   *
+   * @returns Map of scalar names to CustomScalar classes
+   */
+  static getCustomScalars() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, { class: scalarClass }] of this.customScalars) {
+      result.set(name, scalarClass);
+    }
+    return result;
+  }
+  /**
+   * Get the complete schema as an object.
+   *
+   * @returns Schema object with types, queries, mutations, subscriptions, and analytics sections
+   */
+  static getSchema() {
+    const schema = {
+      types: Array.from(this.types.values()),
+      queries: Array.from(this.queries.values()),
+      mutations: Array.from(this.mutations.values()),
+      subscriptions: Array.from(this.subscriptions.values())
+    };
+    if (this.enums.size > 0) {
+      schema.enums = Array.from(this.enums.values());
+    }
+    if (this.interfaces.size > 0) {
+      schema.interfaces = Array.from(this.interfaces.values());
+    }
+    if (this.inputTypes.size > 0) {
+      schema.input_types = Array.from(this.inputTypes.values());
+    }
+    if (this.unions.size > 0) {
+      schema.unions = Array.from(this.unions.values());
+    }
+    if (this.factTables.size > 0) {
+      schema.fact_tables = Array.from(this.factTables.values());
+    }
+    if (this.aggregateQueries.size > 0) {
+      schema.aggregate_queries = Array.from(this.aggregateQueries.values());
+    }
+    if (this.observers.size > 0) {
+      schema.observers = Array.from(this.observers.values());
+    }
+    if (this.customScalars.size > 0) {
+      const customScalars = {};
+      for (const [name, { class: scalarClass, description }] of this.customScalars) {
+        customScalars[name] = {
+          name,
+          description: description ?? "Custom scalar",
+          validate: true
+        };
+        void scalarClass;
+      }
+      schema.customScalars = customScalars;
+    }
+    return schema;
+  }
+  /**
+   * Clear the registry (useful for testing).
+   */
+  static clear() {
+    this.types.clear();
+    this.queries.clear();
+    this.mutations.clear();
+    this.subscriptions.clear();
+    this.enums.clear();
+    this.interfaces.clear();
+    this.inputTypes.clear();
+    this.unions.clear();
+    this.factTables.clear();
+    this.aggregateQueries.clear();
+    this.observers.clear();
+    this.customScalars.clear();
+  }
+};
+
+// src/crud.ts
+var ALL_OPS = /* @__PURE__ */ new Set(["read", "create", "update", "delete"]);
+function pascalToSnake(name) {
+  return name.replace(/(?<!^)([A-Z])/g, "_$1").toLowerCase();
+}
+function pluralize(name) {
+  if (name.endsWith("s") && !name.endsWith("ss")) return name;
+  for (const suffix of ["ss", "sh", "ch", "x", "z"]) {
+    if (name.endsWith(suffix)) return name + "es";
+  }
+  if (/[^aeiou]y$/.test(name)) return name.slice(0, -1) + "ies";
+  return name + "s";
+}
+function parseCrudOps(crud) {
+  if (crud === true) return new Set(ALL_OPS);
+  if (Array.isArray(crud)) {
+    const unknown = crud.filter((op) => !ALL_OPS.has(op));
+    if (unknown.length > 0) {
+      throw new Error(
+        `Unknown CRUD operations: ${unknown.join(", ")}. Valid: read, create, update, delete`
+      );
+    }
+    return new Set(crud);
+  }
+  return /* @__PURE__ */ new Set();
+}
+function generateCrudOperations(typeName, fields, crud, sqlSource, cascade) {
+  const ops = parseCrudOps(crud);
+  if (ops.size === 0) return;
+  if (fields.length === 0) {
+    throw new Error(`Type '${typeName}' has no fields; cannot generate CRUD operations`);
+  }
+  const snake = pascalToSnake(typeName);
+  const view = sqlSource ?? `v_${snake}`;
+  const pkField = fields[0];
+  if (ops.has("read")) {
+    SchemaRegistry.registerQuery(
+      snake,
+      typeName,
+      false,
+      true,
+      [{ name: pkField.name, type: pkField.type, nullable: false }],
+      `Get ${typeName} by ID.`,
+      { sql_source: view }
+    );
+    SchemaRegistry.registerQuery(
+      pluralize(snake),
+      typeName,
+      true,
+      false,
+      [],
+      `List ${typeName} records.`,
+      { sql_source: view, auto_params: { where: true, order_by: true, limit: true, offset: true } }
+    );
+  }
+  if (ops.has("create")) {
+    const args = fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      nullable: f.nullable
+    }));
+    const config2 = {
+      sql_source: `fn_create_${snake}`,
+      operation: "INSERT"
+    };
+    if (cascade) config2.cascade = true;
+    SchemaRegistry.registerMutation(
+      `create_${snake}`,
+      typeName,
+      false,
+      false,
+      args,
+      `Create a new ${typeName}.`,
+      config2
+    );
+  }
+  if (ops.has("update")) {
+    const args = [
+      { name: pkField.name, type: pkField.type, nullable: false },
+      ...fields.slice(1).map((f) => ({ name: f.name, type: f.type, nullable: true }))
+    ];
+    const config2 = {
+      sql_source: `fn_update_${snake}`,
+      operation: "UPDATE"
+    };
+    if (cascade) config2.cascade = true;
+    SchemaRegistry.registerMutation(
+      `update_${snake}`,
+      typeName,
+      false,
+      true,
+      args,
+      `Update an existing ${typeName}.`,
+      config2
+    );
+  }
+  if (ops.has("delete")) {
+    const config2 = {
+      sql_source: `fn_delete_${snake}`,
+      operation: "DELETE"
+    };
+    if (cascade) config2.cascade = true;
+    SchemaRegistry.registerMutation(
+      `delete_${snake}`,
+      typeName,
+      false,
+      false,
+      [{ name: pkField.name, type: pkField.type, nullable: false }],
+      `Delete a ${typeName}.`,
+      config2
+    );
+  }
+}
+
+// src/decorators.ts
+function field(options) {
+  return options;
+}
+function Type(_config) {
+  return function(constructor) {
+    const typeName = constructor.name;
+    SchemaRegistry.registerType(typeName, [], _config?.description, {
+      sqlSource: _config?.sqlSource
+    });
+    return constructor;
+  };
+}
+function Query(config2) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = propertyKey;
+    SchemaRegistry.registerQuery(
+      methodName,
+      "Query",
+      // Placeholder - should be extracted from metadata
+      false,
+      // Placeholder
+      false,
+      // Placeholder
+      [],
+      // Placeholder
+      originalMethod?.toString?.().split("\n")[0] ?? void 0,
+      config2
+    );
+    return descriptor;
+  };
+}
+function Mutation(config2) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = propertyKey;
+    SchemaRegistry.registerMutation(
+      methodName,
+      "Mutation",
+      // Placeholder - should be extracted from metadata
+      false,
+      // Placeholder
+      false,
+      // Placeholder
+      [],
+      // Placeholder
+      originalMethod?.toString?.().split("\n")[0] ?? void 0,
+      config2
+    );
+    return descriptor;
+  };
+}
+function enum_(name, values, config2) {
+  const enumValues = Object.keys(values).map((key) => ({
+    name: key
+  }));
+  SchemaRegistry.registerEnum(name, enumValues, config2?.description);
+  return values;
+}
+function interface_(name, fields, config2) {
+  SchemaRegistry.registerInterface(name, fields, config2?.description);
+  return {};
+}
+function union(name, memberTypes, config2) {
+  SchemaRegistry.registerUnion(name, memberTypes, config2?.description);
+  return {};
+}
+function input(name, fields, config2) {
+  SchemaRegistry.registerInputType(name, fields, config2?.description);
+  return {};
+}
+function registerTypeFields(typeName, fields, description, options) {
+  SchemaRegistry.registerType(typeName, fields, description, options);
+  if (options?.crud) {
+    generateCrudOperations(typeName, fields, options.crud, options.sqlSource, options.cascade);
+  }
+}
+function registerQuery(name, returnType, returnsList, nullable, args, description, config2) {
+  SchemaRegistry.registerQuery(name, returnType, returnsList, nullable, args, description, config2);
+}
+function registerMutation(name, returnType, returnsList, nullable, args, description, config2) {
+  SchemaRegistry.registerMutation(
+    name,
+    returnType,
+    returnsList,
+    nullable,
+    args,
+    description,
+    config2
+  );
+}
+function Subscription(config2) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const methodName = propertyKey;
+    const entityType = config2?.entityType || "Subscription";
+    SchemaRegistry.registerSubscription(
+      methodName,
+      entityType,
+      false,
+      // Placeholder for nullable
+      [],
+      // Placeholder for arguments
+      originalMethod?.toString?.().split("\n")[0] ?? void 0,
+      config2
+    );
+    return descriptor;
+  };
+}
+function registerSubscription(name, entityType, nullable, args, description, config2) {
+  SchemaRegistry.registerSubscription(name, entityType, nullable, args, description, config2);
+}
+function Scalar(target) {
+  if (!isCustomScalarSubclass(target)) {
+    const name = target.name ?? "(unknown)";
+    throw new TypeError(
+      `@Scalar can only be applied to CustomScalar subclasses, got ${name}`
+    );
+  }
+  const instance = new target();
+  const scalarName = instance.name;
+  if (!scalarName || typeof scalarName !== "string") {
+    throw new Error(
+      `CustomScalar ${target.name} must have a 'name' property of type string`
+    );
+  }
+  SchemaRegistry.registerScalar(scalarName, target, target.toString());
+  return target;
+}
+function isCustomScalarSubclass(target) {
+  try {
+    return target.prototype instanceof CustomScalar || target === CustomScalar;
+  } catch {
+    return false;
+  }
+}
+
+// src/schema.ts
+import * as fs from "fs";
+var BUILTIN_SCALARS = /* @__PURE__ */ new Set(["String", "Int", "Float", "Boolean", "ID"]);
+function validateSchemaBeforeExport(schema) {
+  const registeredTypeNames = /* @__PURE__ */ new Set([
+    ...schema.types.map((t) => t.name),
+    ...(schema.enums ?? []).map((e) => e.name),
+    ...BUILTIN_SCALARS
+  ]);
+  const errors = [];
+  for (const query of schema.queries) {
+    const ret = query.return_type;
+    if (ret && !registeredTypeNames.has(ret)) {
+      errors.push(
+        `Query '${query.name}' has return type '${ret}' which is not a registered type.`
+      );
+    }
+  }
+  for (const mutation of schema.mutations) {
+    const ret = mutation.return_type;
+    if (ret && !registeredTypeNames.has(ret)) {
+      errors.push(
+        `Mutation '${mutation.name}' has return type '${ret}' which is not a registered type.`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Schema validation failed before export. Fix the following errors:
+  - ${errors.join("\n  - ")}`
+    );
+  }
+}
+var ConfigHolder = class {
+  static pendingConfig = null;
+};
+function config(configObj) {
+  ConfigHolder.pendingConfig = configObj;
+}
+function exportSchema(outputPath, options = {}) {
+  const { pretty = true } = options;
+  const schema = SchemaRegistry.getSchema();
+  validateSchemaBeforeExport(schema);
+  const content = pretty ? JSON.stringify(schema, null, 2) + "\n" : JSON.stringify(schema);
+  fs.writeFileSync(outputPath, content, { encoding: "utf-8" });
+  console.log(`\u2705 Schema exported to ${outputPath}`);
+  console.log(`   Types: ${schema.types.length}`);
+  console.log(`   Queries: ${schema.queries.length}`);
+  console.log(`   Mutations: ${schema.mutations.length}`);
+  if (schema.fact_tables) {
+    console.log(`   Fact Tables: ${schema.fact_tables.length}`);
+  }
+  if (schema.aggregate_queries) {
+    console.log(`   Aggregate Queries: ${schema.aggregate_queries.length}`);
+  }
+  if (schema.observers) {
+    console.log(`   Observers: ${schema.observers.length}`);
+  }
+}
+function getSchemaDict() {
+  return SchemaRegistry.getSchema();
+}
+function exportSchemaToString(options = {}) {
+  const { pretty = true } = options;
+  const schema = SchemaRegistry.getSchema();
+  return pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
+}
+function exportTypes(outputPath, options = {}) {
+  const { pretty = true } = options;
+  const fullSchema = SchemaRegistry.getSchema();
+  const minimalSchema = {
+    types: fullSchema.types || [],
+    enums: fullSchema.enums || [],
+    input_types: fullSchema.input_types || [],
+    interfaces: fullSchema.interfaces || []
+  };
+  const content = pretty ? JSON.stringify(minimalSchema, null, 2) + "\n" : JSON.stringify(minimalSchema);
+  fs.writeFileSync(outputPath, content, { encoding: "utf-8" });
+  console.log(`\u2705 Types exported to ${outputPath}`);
+  console.log(`   Types: ${minimalSchema.types.length}`);
+  if (minimalSchema.enums.length > 0) {
+    console.log(`   Enums: ${minimalSchema.enums.length}`);
+  }
+  if (minimalSchema.input_types.length > 0) {
+    console.log(`   Input types: ${minimalSchema.input_types.length}`);
+  }
+  if (minimalSchema.interfaces.length > 0) {
+    console.log(`   Interfaces: ${minimalSchema.interfaces.length}`);
+  }
+  console.log(`   \u2192 Use with: fraiseql compile fraiseql.toml --types ${outputPath}`);
+}
+
+// src/validators.ts
+var ScalarValidationError = class extends Error {
+  /**
+   * Creates a new ScalarValidationError.
+   *
+   * @param scalarName - Name of the scalar that failed validation
+   * @param context - The validation context ("serialize", "parseValue", or "parseLiteral")
+   * @param message - The underlying error message
+   */
+  constructor(scalarName, context, message) {
+    super(
+      `Scalar ${JSON.stringify(scalarName)} validation failed in ${context}: ${message}`
+    );
+    this.scalarName = scalarName;
+    this.context = context;
+    this.name = "ScalarValidationError";
+  }
+};
+function validateCustomScalar(scalarClass, value, context = "parseValue") {
+  const instance = new scalarClass();
+  const scalarName = instance.name;
+  try {
+    switch (context) {
+      case "serialize":
+        return instance.serialize(value);
+      case "parseValue":
+        return instance.parseValue(value);
+      case "parseLiteral":
+        return instance.parseLiteral(value);
+      default:
+        throw new Error(`Unknown validation context: ${context}`);
+    }
+  } catch (error) {
+    if (error instanceof ScalarValidationError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ScalarValidationError(scalarName, context, message);
+  }
+}
+function getAllCustomScalars() {
+  return SchemaRegistry.getCustomScalars();
+}
+
+// src/observers.ts
+var DEFAULT_RETRY_CONFIG = {
+  max_attempts: 3,
+  backoff_strategy: "exponential",
+  initial_delay_ms: 100,
+  max_delay_ms: 6e4
+};
+function Observer(config2) {
+  return function(_target, propertyKey, _descriptor) {
+    SchemaRegistry.registerObserver(
+      propertyKey,
+      config2.entity,
+      config2.event,
+      config2.actions,
+      config2.condition,
+      config2.retry
+    );
+  };
+}
+function webhook(url, options) {
+  if (url === void 0 && options?.url_env === void 0) {
+    throw new Error("Either url or url_env must be provided");
+  }
+  const action = {
+    type: "webhook",
+    headers: { "Content-Type": "application/json", ...options?.headers ?? {} }
+  };
+  if (url !== void 0) {
+    action.url = url;
+  }
+  if (options?.url_env !== void 0) {
+    action.url_env = options.url_env;
+  }
+  if (options?.body_template !== void 0) {
+    action.body_template = options.body_template;
+  }
+  return action;
+}
+function slack(channel, message, options) {
+  const action = {
+    type: "slack",
+    channel,
+    message,
+    webhook_url_env: options?.webhook_url_env ?? "SLACK_WEBHOOK_URL"
+  };
+  if (options?.webhook_url !== void 0) {
+    action.webhook_url = options.webhook_url;
+  }
+  return action;
+}
+function email(to, subject, body, options) {
+  const action = {
+    type: "email",
+    to,
+    subject,
+    body
+  };
+  if (options?.from_email !== void 0) {
+    action.from = options.from_email;
+  }
+  return action;
+}
+
+// src/errors.ts
+var FraiseQLError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "FraiseQLError";
+  }
+};
+var GraphQLError = class extends FraiseQLError {
+  errors;
+  constructor(errors) {
+    super(errors[0]?.message ?? "GraphQL error");
+    this.name = "GraphQLError";
+    this.errors = errors;
+  }
+};
+var NetworkError = class extends FraiseQLError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends NetworkError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var AuthenticationError = class extends FraiseQLError {
+  statusCode;
+  constructor(statusCode) {
+    super(`Authentication failed (HTTP ${statusCode})`);
+    this.name = "AuthenticationError";
+    this.statusCode = statusCode;
+  }
+};
+var RateLimitError = class extends FraiseQLError {
+  retryAfterMs;
+  constructor(retryAfterMs) {
+    super("Rate limit exceeded");
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+
+// src/http-retry.ts
+async function executeWithRetry(fn, config2 = {}) {
+  const {
+    maxAttempts = 1,
+    baseDelayMs = 1e3,
+    maxDelayMs = 3e4,
+    jitter = true,
+    retryOn = [NetworkError, TimeoutError],
+    onRetry
+  } = config2;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt === maxAttempts) throw error;
+      const isRetryable = retryOn.some(
+        (ErrorClass) => error instanceof ErrorClass
+      );
+      if (!isRetryable) throw error;
+      lastError = error;
+      onRetry?.(attempt, lastError);
+      const delay = Math.min(
+        baseDelayMs * Math.pow(2, attempt - 1),
+        maxDelayMs
+      );
+      const actualDelay = jitter ? delay * (0.5 + Math.random() * 0.5) : delay;
+      await new Promise((resolve) => setTimeout(resolve, actualDelay));
+    }
+  }
+  throw lastError;
+}
+
+// src/client.ts
+var FraiseQLClient = class {
+  url;
+  authorization;
+  timeoutMs;
+  retry;
+  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);
+  }
+  async resolveAuth() {
+    if (this.authorization === void 0) return void 0;
+    if (typeof this.authorization === "string") return this.authorization;
+    return this.authorization();
+  }
+  async buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.extraHeaders
+    };
+    const auth = await this.resolveAuth();
+    if (auth !== void 0) {
+      headers["Authorization"] = auth;
+    }
+    return headers;
+  }
+  async executeRequest(body) {
+    return executeWithRetry(async () => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      let response;
+      try {
+        response = await this.fetchFn(this.url, {
+          method: "POST",
+          headers: await this.buildHeaders(),
+          body,
+          signal: controller.signal
+        });
+      } catch (error) {
+        if (error instanceof Error && (error.name === "AbortError" || error.message.toLowerCase().includes("abort"))) {
+          throw new TimeoutError();
+        }
+        throw new NetworkError(
+          error instanceof Error ? error.message : "Network request failed",
+          { cause: error }
+        );
+      } finally {
+        clearTimeout(timer);
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw new AuthenticationError(response.status);
+      }
+      if (response.status === 429) {
+        const retryAfterHeader = response.headers.get("Retry-After");
+        const retryAfterMs = retryAfterHeader ? parseInt(retryAfterHeader, 10) * 1e3 : void 0;
+        throw new RateLimitError(
+          Number.isNaN(retryAfterMs) ? void 0 : retryAfterMs
+        );
+      }
+      if (!response.ok) {
+        throw new NetworkError(
+          `HTTP ${response.status}: ${response.statusText}`
+        );
+      }
+      let json;
+      try {
+        json = await response.json();
+      } catch (error) {
+        throw new NetworkError("Failed to parse JSON response", {
+          cause: error
+        });
+      }
+      if (json.errors !== null && json.errors !== void 0 && json.errors.length > 0) {
+        throw new GraphQLError(json.errors);
+      }
+      return json.data ?? {};
+    }, this.retry);
+  }
+  async query(query, variables, operationName) {
+    const body = JSON.stringify({
+      query,
+      variables,
+      ...operationName && { operationName }
+    });
+    return this.executeRequest(body);
+  }
+  async mutate(mutation, variables, operationName) {
+    const body = JSON.stringify({
+      query: mutation,
+      variables,
+      ...operationName && { operationName }
+    });
+    return this.executeRequest(body);
+  }
+};
+
+// src/index.ts
+var version = "2.0.0-alpha.1";
+export {
+  AuthenticationError,
+  CustomScalar,
+  DEFAULT_RETRY_CONFIG,
+  FraiseQLClient,
+  FraiseQLError,
+  GraphQLError,
+  Mutation,
+  NetworkError,
+  Observer,
+  Query,
+  RateLimitError,
+  SCALAR_NAMES,
+  Scalar,
+  ScalarValidationError,
+  SchemaRegistry,
+  Subscription,
+  TimeoutError,
+  Type,
+  config,
+  email,
+  enum_,
+  executeWithRetry,
+  exportSchema,
+  exportSchemaToString,
+  exportTypes,
+  extractFieldInfo,
+  extractFunctionSignature,
+  field,
+  generateCrudOperations,
+  getAllCustomScalars,
+  getSchemaDict,
+  input,
+  interface_,
+  isScalarType,
+  registerMutation,
+  registerQuery,
+  registerSubscription,
+  registerTypeFields,
+  slack,
+  typeToGraphQL,
+  union,
+  validateCustomScalar,
+  version,
+  webhook
+};