silgi 0.4.11 → 0.5.0

package/dist/core/index.mjs

@@ -818,48 +818,195 @@ function normalizeResult(result) {
   return result;
 }
 
-var SilgiErrorCode = /* @__PURE__ */ ((SilgiErrorCode2) => {
-  SilgiErrorCode2["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
-  SilgiErrorCode2["AUTH_MISSING_CONTEXT"] = "AUTH_MISSING_CONTEXT";
-  SilgiErrorCode2["AUTH_INVALID_CONTEXT"] = "AUTH_INVALID_CONTEXT";
-  SilgiErrorCode2["AUTH_PERMISSION_DENIED"] = "AUTH_PERMISSION_DENIED";
-  SilgiErrorCode2["PLUGIN_ERROR"] = "PLUGIN_ERROR";
-  SilgiErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
-  SilgiErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
-  SilgiErrorCode2["CACHE_ERROR"] = "CACHE_ERROR";
-  SilgiErrorCode2["PLUGIN_ALREADY_EXISTS"] = "PLUGIN_ALREADY_EXISTS";
-  SilgiErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
-  SilgiErrorCode2["PLUGIN_INIT_ERROR"] = "PLUGIN_INIT_ERROR";
-  return SilgiErrorCode2;
-})(SilgiErrorCode || {});
+var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
+  HttpStatus2[HttpStatus2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatus2[HttpStatus2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatus2[HttpStatus2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatus2[HttpStatus2["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+  HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
+  HttpStatus2[HttpStatus2["CREATED"] = 201] = "CREATED";
+  HttpStatus2[HttpStatus2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatus2[HttpStatus2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatus2[HttpStatus2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatus2[HttpStatus2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatus2[HttpStatus2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatus2[HttpStatus2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatus2[HttpStatus2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  HttpStatus2[HttpStatus2["IM_USED"] = 226] = "IM_USED";
+  HttpStatus2[HttpStatus2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  HttpStatus2[HttpStatus2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatus2[HttpStatus2["FOUND"] = 302] = "FOUND";
+  HttpStatus2[HttpStatus2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatus2[HttpStatus2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatus2[HttpStatus2["USE_PROXY"] = 305] = "USE_PROXY";
+  HttpStatus2[HttpStatus2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatus2[HttpStatus2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatus2[HttpStatus2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatus2[HttpStatus2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatus2[HttpStatus2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatus2[HttpStatus2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatus2[HttpStatus2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatus2[HttpStatus2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatus2[HttpStatus2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatus2[HttpStatus2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatus2[HttpStatus2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatus2[HttpStatus2["GONE"] = 410] = "GONE";
+  HttpStatus2[HttpStatus2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatus2[HttpStatus2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatus2[HttpStatus2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatus2[HttpStatus2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatus2[HttpStatus2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  HttpStatus2[HttpStatus2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatus2[HttpStatus2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
+  HttpStatus2[HttpStatus2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatus2[HttpStatus2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatus2[HttpStatus2["LOCKED"] = 423] = "LOCKED";
+  HttpStatus2[HttpStatus2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatus2[HttpStatus2["TOO_EARLY"] = 425] = "TOO_EARLY";
+  HttpStatus2[HttpStatus2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatus2[HttpStatus2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatus2[HttpStatus2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatus2[HttpStatus2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatus2[HttpStatus2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatus2[HttpStatus2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatus2[HttpStatus2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatus2[HttpStatus2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatus2[HttpStatus2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatus2[HttpStatus2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatus2[HttpStatus2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatus2[HttpStatus2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatus2[HttpStatus2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatus2[HttpStatus2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatus2[HttpStatus2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatus2;
+})(HttpStatus || {});
+var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+  ErrorSeverity2["DEBUG"] = "DEBUG";
+  ErrorSeverity2["INFO"] = "INFO";
+  ErrorSeverity2["WARNING"] = "WARNING";
+  ErrorSeverity2["ERROR"] = "ERROR";
+  ErrorSeverity2["CRITICAL"] = "CRITICAL";
+  return ErrorSeverity2;
+})(ErrorSeverity || {});
+var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
+  ErrorCategory2["AUTHENTICATION"] = "auth";
+  ErrorCategory2["AUTHORIZATION"] = "authorization";
+  ErrorCategory2["VALIDATION"] = "validation";
+  ErrorCategory2["BUSINESS"] = "business";
+  ErrorCategory2["INFRASTRUCTURE"] = "infrastructure";
+  ErrorCategory2["EXTERNAL"] = "external";
+  ErrorCategory2["UNKNOWN"] = "unknown";
+  return ErrorCategory2;
+})(ErrorCategory || {});
+class ErrorFactory {
+  static createMetadata(metadata) {
+    return {
+      timestamp: Date.now(),
+      ...metadata
+    };
+  }
+  static create(options) {
+    return new SilgiError({
+      code: options.code ?? options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
+      message: options.message,
+      category: options.category ?? "unknown" /* UNKNOWN */,
+      severity: options.severity ?? "ERROR" /* ERROR */,
+      httpStatus: options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
+      metadata: this.createMetadata(options.metadata),
+      cause: options.cause,
+      context: options.context
+    });
+  }
+  // Predefined error creators
+  static authenticationError(message, context) {
+    return this.create({
+      message,
+      code: 401,
+      category: "auth" /* AUTHENTICATION */,
+      severity: "ERROR" /* ERROR */,
+      httpStatus: 401 /* UNAUTHORIZED */,
+      context
+    });
+  }
+  static authorizationError(message, context) {
+    return this.create({
+      message,
+      code: 403,
+      category: "authorization" /* AUTHORIZATION */,
+      severity: "ERROR" /* ERROR */,
+      httpStatus: 403 /* FORBIDDEN */,
+      context
+    });
+  }
+  static validationError(message, context) {
+    return this.create({
+      message,
+      code: 400,
+      category: "validation" /* VALIDATION */,
+      severity: "WARNING" /* WARNING */,
+      httpStatus: 400 /* BAD_REQUEST */,
+      context
+    });
+  }
+  static notFoundError(message, context) {
+    return this.create({
+      message,
+      code: 404,
+      category: "business" /* BUSINESS */,
+      severity: "WARNING" /* WARNING */,
+      httpStatus: 404 /* NOT_FOUND */,
+      context
+    });
+  }
+  static internalError(message, cause) {
+    return this.create({
+      message,
+      code: 500,
+      category: "infrastructure" /* INFRASTRUCTURE */,
+      severity: "CRITICAL" /* CRITICAL */,
+      httpStatus: 500 /* INTERNAL_SERVER_ERROR */,
+      cause
+    });
+  }
+}
 class SilgiError extends Error {
   code;
-  details;
-  meta;
-  timestamp;
+  category;
+  severity;
+  httpStatus;
+  metadata;
+  context;
   cause;
-  constructor(options) {
-    super(options.message);
+  constructor(error) {
+    super(error.message);
     this.name = "SilgiError";
-    this.code = options.code;
-    this.details = options.details;
-    this.meta = options.meta;
-    this.cause = options.cause;
-    this.timestamp = Date.now();
+    this.code = error.code;
+    this.category = error.category;
+    this.severity = error.severity;
+    this.httpStatus = error.httpStatus;
+    this.metadata = error.metadata ?? { timestamp: Date.now() };
+    this.context = error.context;
+    this.cause = error.cause;
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
     }
   }
-  // Improve error formatting
   toString() {
-    let str = `${this.name} [${this.code}]: ${this.message}`;
-    if (this.details) {
+    let str = `${this.name} [${this.code}] ${this.severity}: ${this.message}`;
+    str += `
+Category: ${this.category}`;
+    str += `
+HTTP Status: ${this.httpStatus}`;
+    if (this.context) {
       str += `
-Details: ${JSON.stringify(this.details, null, 2)}`;
+Context: ${JSON.stringify(this.context, null, 2)}`;
     }
-    if (this.meta) {
+    if (this.metadata) {
       str += `
-Meta: ${JSON.stringify(this.meta, null, 2)}`;
+Metadata: ${JSON.stringify(this.metadata, null, 2)}`;
     }
     if (this.stack) {
       str += `
@@ -872,38 +1019,50 @@ ${this.stack}`;
       name: this.name,
       code: this.code,
       message: this.message,
-      details: this.details,
-      meta: this.meta,
-      timestamp: this.timestamp,
+      category: this.category,
+      severity: this.severity,
+      httpStatus: this.httpStatus,
+      metadata: this.metadata,
+      context: this.context,
       stack: this.stack
     };
   }
-  static createFrom(error, code = "UNKNOWN_ERROR") {
+  static isError(error) {
+    return error instanceof SilgiError;
+  }
+  static from(error) {
     if (error instanceof SilgiError) {
       return error;
     }
-    return new SilgiError({
-      code,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error : undefined
-    });
-  }
-  static isSilgiError(error) {
-    return error instanceof SilgiError;
+    return ErrorFactory.internalError(
+      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error : undefined
+    );
   }
 }
-
-function uriParseError(message, code) {
-  throw new SilgiError({
-    code: `URI_PARSE_ERROR_${code}`,
-    message
-  });
+function isBaseError(error) {
+  return typeof error === "object" && error !== null && "code" in error && "message" in error && "category" in error && "severity" in error && "httpStatus" in error;
 }
+
 function parseURI(uri, uris) {
-  if (!uri)
-    throw uriParseError("URI cannot be empty", "EMPTY_URI");
-  else if (!uris)
-    throw uriParseError("URIs is not nullable", "NULL_URIS");
+  if (!uri) {
+    throw ErrorFactory.create({
+      message: "URI cannot be empty",
+      httpStatus: HttpStatus.BAD_REQUEST,
+      context: {
+        uri
+      }
+    });
+  }
+  if (!uris) {
+    throw ErrorFactory.create({
+      message: "URIs configuration is not provided",
+      httpStatus: HttpStatus.INTERNAL_SERVER_ERROR,
+      context: {
+        uri
+      }
+    });
+  }
   const cleanUri = uri.replace(/^\/*(srn\/)?/, "").replace(/\/*$/, "");
   const [path, queryString] = cleanUri.split("?");
   const parts = path.split("/");
@@ -911,29 +1070,76 @@ function parseURI(uri, uris) {
     queryString.split("&").map((param) => param.split("="))
   ) : undefined;
   const method = query?.method ? query?.method.toLowerCase() : undefined;
-  if (method && parts.length < 3 || !method && parts.length < 4)
-    throw uriParseError("Invalid URI format lengt", "INVALID_FORMAT");
+  if (method && parts.length < 3 || !method && parts.length < 4) {
+    throw ErrorFactory.create({
+      message: "Invalid URI format: Insufficient path segments",
+      httpStatus: HttpStatus.BAD_REQUEST,
+      context: {
+        uri,
+        cleanUri,
+        partsLength: parts.length,
+        method,
+        expectedMinLength: method ? 3 : 4
+      }
+    });
+  }
   const namespaceName = parts[0];
   const serviceName = parts[1];
   const methodName = method || parts[2];
   const actionName = method ? parts[2] : parts[3];
-  if (!namespaceName || !serviceName || !methodName || !actionName)
-    throw uriParseError("Invalid URI format", "INVALID_FORMAT");
+  if (!namespaceName || !serviceName || !methodName || !actionName) {
+    throw ErrorFactory.create({
+      message: "Invalid URI format: Missing required path segments",
+      httpStatus: HttpStatus.BAD_REQUEST,
+      context: {
+        uri,
+        namespaceName,
+        serviceName,
+        methodName,
+        actionName
+      }
+    });
+  }
   const hasParameters = parts.length > 4;
   const baseUri = `${namespaceName}/${serviceName}/${methodName}/${actionName}`;
   const template = uris[baseUri];
   if (template === "") {
-    if (hasParameters)
-      throw uriParseError("No parameters expected for this route", "UNEXPECTED_PARAMS");
+    if (hasParameters) {
+      throw ErrorFactory.create({
+        message: "Parameters are not allowed for this route",
+        httpStatus: HttpStatus.BAD_REQUEST,
+        context: {
+          uri,
+          baseUri,
+          extraParams: parts.slice(4)
+        }
+      });
+    }
   } else if (!template) {
-    throw uriParseError("No route found for URI", "ROUTE_NOT_FOUND");
+    throw ErrorFactory.create({
+      message: "Route not found",
+      httpStatus: HttpStatus.NOT_FOUND,
+      context: {
+        uri,
+        baseUri
+      }
+    });
   }
   const routeTemplate = typeof template === "string" ? template : template.pattern;
   const validators = typeof template === "string" ? undefined : template.validators;
   const routerParams = {};
   if (routeTemplate === "") {
-    if (parts.length > 4)
-      throw uriParseError("No parameters expected for this route", "UNEXPECTED_PARAMS");
+    if (parts.length > 4) {
+      throw ErrorFactory.create({
+        message: "Parameters are not allowed for this route",
+        httpStatus: HttpStatus.BAD_REQUEST,
+        context: {
+          uri,
+          baseUri,
+          extraParams: parts.slice(4)
+        }
+      });
+    }
   } else {
     const templateParts = routeTemplate.split("/").filter(Boolean);
     const paramValues = parts.slice(4);
@@ -944,7 +1150,16 @@ function parseURI(uri, uris) {
         const paramValue = paramValues[valueIndex];
         if (validators?.[paramName] && paramValue) {
           if (!validators[paramName](paramValue)) {
-            throw uriParseError(`Invalid value for parameter ${paramName}`, "INVALID_PARAM_VALUE");
+            throw ErrorFactory.create({
+              message: `Invalid parameter value: ${paramName}`,
+              httpStatus: HttpStatus.UNPROCESSABLE_ENTITY,
+              context: {
+                uri,
+                paramName,
+                paramValue,
+                validatorName: paramName
+              }
+            });
           }
         }
         routerParams[paramName] = paramValue || undefined;
@@ -1036,9 +1251,16 @@ async function generateStorageKey(params) {
   ].filter(Boolean);
   if (storageOptions?.scope === "request") {
     if (!requestId) {
-      throw new SilgiError({
-        code: "CACHE_ERROR",
-        message: "Request ID is required for request-scoped cache"
+      throw ErrorFactory.create({
+        code: HttpStatus.BAD_REQUEST,
+        message: "Request ID is required for request-scoped cache",
+        context: {
+          requestId,
+          operation,
+          input,
+          storageOptions,
+          keyGenerator
+        }
       });
     }
     parts.push(requestId);
@@ -1143,8 +1365,13 @@ function getFetch(url, opts, localFetch) {
   return globalThis.$fetch;
 }
 function fillPath(path, params) {
-  if (!params)
+  if (!params) {
+    if (path.includes(":"))
+      throw new Error("Parametreler dogru kullanmal\u0131s\u0131n\u0131z");
     return path;
+  }
+  if (!path.includes(":"))
+    throw new Error("Path parametler : ile belirtilmelidir");
   let result = path;
   for (const [key, value] of Object.entries(params)) {
     result = result.replace(`:${key}`, value);
@@ -1294,34 +1521,25 @@ function silgi(event) {
 async function execute(uriString, input, event) {
   const silgiCtx = useSilgi();
   if (event) {
-    silgiCtx.callHook("event:before", event);
+    await silgiCtx.callHook("event:before", event);
   }
   let success = false;
   let cached = false;
-  let error;
   let result;
-  const operation = parseURI(uriString, silgiCtx.uris);
-  if (!operation) {
-    throw new SilgiError({
-      code: "INVALID_URI",
-      message: `Invalid URI: ${uriString}`
-    });
-  }
-  const hookContext = {
-    operation,
-    input,
-    event
-  };
   try {
+    const operation = parseURI(uriString, silgiCtx.uris);
+    if (!operation) {
+      throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
+    }
     const handler = silgiCtx.scannedHandlers.get(operation.uri);
     if (!handler) {
-      return {
-        success: false,
-        error: {
-          code: "METHOD_NOT_FOUND",
-          message: `Method ${String(operation.methodName)} not found`
+      throw ErrorFactory.create({
+        message: "Action not found",
+        httpStatus: HttpStatus.NOT_FOUND,
+        context: {
+          uri: uriString
         }
-      };
+      });
     }
     await silgiCtx.callHook("action:before", {
       operation,
@@ -1357,31 +1575,19 @@ async function execute(uriString, input, event) {
         await useStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
       }
     }
-    return { success: true, data: normalizeResult(result), cached };
+    return result;
   } catch (err) {
-    error = err instanceof Error ? err : new Error("Unknown error");
-    if (error instanceof SilgiError) {
-      return {
-        success: false,
-        error: {
-          code: error.code,
-          message: error.message,
-          details: error.details
-        }
-      };
-    }
     await silgiCtx.callHook("action:error", {
-      ...hookContext,
-      error,
+      input,
+      event,
+      error: err instanceof Error ? err : new Error(String(err)),
       timestamp: Date.now()
     });
-    return {
-      success: false,
-      error: {
-        code: SilgiErrorCode.EXECUTION_ERROR,
-        message: error.message || String(error)
-      }
-    };
+    silgiCtx.captureError(SilgiError.from(err), {
+      event,
+      tags: ["execute"]
+    });
+    throw err;
   }
 }
 async function cacheExecute(input, operation, handler, event) {
@@ -1453,4 +1659,4 @@ function createShared(shared) {
   return shared;
 }
 
-export { SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, getEvent, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiGenerateType, useSilgi };
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, getEvent, isBaseError, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiGenerateType, useSilgi };

package/dist/kit/index.d.mts

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { GraphQLSchema } from 'graphql';
 import { SilgiCLI, GraphQLJSON, SilgiPreset, SilgiPresetMeta } from 'silgi/types';
-import { w as ModuleOptions, y as ModuleDefinition, F as SilgiModule } from '../shared/silgi.DQSwjP5u.mjs';
+import { M as ModuleOptions, a as ModuleDefinition, S as SilgiModule } from '../shared/silgi.CN_giHTc.mjs';
 import 'defu';
 import '@graphql-tools/utils';
 import 'pkg-types';
@@ -17,7 +17,6 @@ import 'chokidar';
 import 'compatx';
 import 'unimport/unplugin';
 import 'std-env';
-import '../shared/silgi.40ZJYm8F.mjs';
 
 /**
  * Resolve a module from a given root path using an algorithm patterned on
@@ -34,6 +33,10 @@ declare function exportGraphQLInterfaceType(silgi: SilgiCLI, schema: GraphQLSche
 
 declare function extractGraphQLSchemaToJSON(schema: GraphQLSchema): GraphQLJSON;
 
+declare function isNuxt(): boolean;
+declare function isNitro(): boolean;
+declare function isH3(): boolean;
+
 /**
  * Define a Silgi module, automatically merging defaults with user provided options, installing
  * any hooks that are provided, and calling an optional setup function for full control.
@@ -87,4 +90,4 @@ declare function resolveSilgiModule(base: string, paths: string[]): Promise<stri
 
 declare function relativeWithDot(from: string, to: string): string;
 
-export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, isH3, isNitro, isNuxt, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/kit/index.d.ts

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { GraphQLSchema } from 'graphql';
 import { SilgiCLI, GraphQLJSON, SilgiPreset, SilgiPresetMeta } from 'silgi/types';
-import { w as ModuleOptions, y as ModuleDefinition, F as SilgiModule } from '../shared/silgi.yr8vHHvd.js';
+import { M as ModuleOptions, a as ModuleDefinition, S as SilgiModule } from '../shared/silgi.CN_giHTc.js';
 import 'defu';
 import '@graphql-tools/utils';
 import 'pkg-types';
@@ -17,7 +17,6 @@ import 'chokidar';
 import 'compatx';
 import 'unimport/unplugin';
 import 'std-env';
-import '../shared/silgi.40ZJYm8F.js';
 
 /**
  * Resolve a module from a given root path using an algorithm patterned on
@@ -34,6 +33,10 @@ declare function exportGraphQLInterfaceType(silgi: SilgiCLI, schema: GraphQLSche
 
 declare function extractGraphQLSchemaToJSON(schema: GraphQLSchema): GraphQLJSON;
 
+declare function isNuxt(): boolean;
+declare function isNitro(): boolean;
+declare function isH3(): boolean;
+
 /**
  * Define a Silgi module, automatically merging defaults with user provided options, installing
  * any hooks that are provided, and calling an optional setup function for full control.
@@ -87,4 +90,4 @@ declare function resolveSilgiModule(base: string, paths: string[]): Promise<stri
 
 declare function relativeWithDot(from: string, to: string): string;
 
-export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, isH3, isNitro, isNuxt, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/kit/index.mjs

@@ -5,6 +5,7 @@ import { relative, resolve, dirname, normalize, isAbsolute, join } from 'pathe';
 import { colors } from 'consola/utils';
 import { getProperty } from 'dot-prop';
 import { extractGraphQLSchemaToJSON as extractGraphQLSchemaToJSON$1 } from 'silgi/kit';
+import { useSilgi } from 'silgi/core';
 import { defu } from 'defu';
 import { u as useSilgiCLI, c as checkSilgiCompatibility, t as tryUseSilgiCLI } from '../cli/compatibility.mjs';
 import { existsSync, promises } from 'node:fs';
@@ -164,6 +165,28 @@ function extractGraphQLSchemaToJSON(schema) {
   return result;
 }
 
+function isNuxt() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nitro" || silgi.options.present === "h3" || silgi.options.present === "nuxt") {
+    return true;
+  }
+  return false;
+}
+function isNitro() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "nitro" || silgi.options.present === "h3") {
+    return true;
+  }
+  return false;
+}
+function isH3() {
+  const silgi = useSilgi();
+  if (silgi.options.present === "h3") {
+    return true;
+  }
+  return false;
+}
+
 function defineSilgiModule(definition) {
   if (definition) {
     return _defineSilgiModule(definition);
@@ -313,4 +336,4 @@ function relativeWithDot(from, to) {
   return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
 }
 
-export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory$1 as isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "0.4.11";
+const version = "0.5.0";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "0.4.11";
+const version = "0.5.0";
 
 export { version };

package/dist/presets/_types.gen.d.ts

@@ -2,4 +2,4 @@ export interface PresetOptions {
 }
 export declare const presetsWithConfig: readonly [];
 export type PresetName = "h3" | "nitro" | "npm-package" | "nuxt";
-export type PresetNameInput = "h3" | "nitro" | "npm-package" | "npmPackage" | "npm_package" | "nuxt" | (string & {});
+export type PresetNameInput = "h3" | "nitro" | "npm-package" | "nuxt" | (string & {});