@tailor-platform/sdk 2.3.0 → 2.5.0

package/dist/plugin/builtin/kysely-type/index.mjs

@@ -1,275 +1 @@
-import { t as multiline } from "../../../multiline-sfHpTZZK.mjs";
-
-//#region src/plugin/builtin/kysely-type/type-processor.ts
-/**
-* Get the enum type definition.
-* @param fieldConfig - The field configuration
-* @returns The enum type as a string union
-*/
-function getEnumType(fieldConfig) {
-	const allowedValues = fieldConfig.allowedValues;
-	if (allowedValues && Array.isArray(allowedValues)) return allowedValues.map((v) => {
-		return `"${typeof v === "string" ? v : v.value}"`;
-	}).join(" | ");
-	return "string";
-}
-/**
-* Get the nested object type definition.
-* @param fieldConfig - The field configuration
-* @returns The nested type with used utility types
-*/
-function getNestedType(fieldConfig) {
-	const fields = fieldConfig.fields;
-	if (!fields || typeof fields !== "object") return {
-		type: "string",
-		usedUtilityTypes: {
-			Timestamp: false,
-			Serial: false
-		}
-	};
-	const fieldResults = Object.entries(fields).map(([fieldName, config]) => {
-		const result = generateFieldType(config);
-		return {
-			fieldType: `${fieldName}${config.required !== true ? "?" : ""}: ${result.type}`,
-			usedUtilityTypes: result.usedUtilityTypes
-		};
-	});
-	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
-		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || result.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	const fieldTypes = fieldResults.map((r) => r.fieldType);
-	const obj = `{\n  ${fieldTypes.join(";\n  ")}${fieldTypes.length > 0 ? ";" : ""}\n}`;
-	const hasOptionalFields = Object.values(fields).some((config) => config.required !== true);
-	const hasGeneratedFields = Object.values(fields).some((config) => config.hooks?.create || config.default !== void 0);
-	if (aggregatedUtilityTypes.Timestamp || hasOptionalFields || hasGeneratedFields) return {
-		type: `ObjectColumnType<${obj}>`,
-		usedUtilityTypes: aggregatedUtilityTypes
-	};
-	return {
-		type: obj,
-		usedUtilityTypes: aggregatedUtilityTypes
-	};
-}
-/**
-* Get the base Kysely type for a field (without array/null modifiers).
-* @param fieldConfig - The field configuration
-* @returns The base type with used utility types
-*/
-function getBaseType(fieldConfig) {
-	const fieldType = fieldConfig.type;
-	const usedUtilityTypes = {
-		Timestamp: false,
-		Serial: false
-	};
-	let type;
-	switch (fieldType) {
-		case "uuid":
-		case "string":
-		case "decimal":
-			type = "string";
-			break;
-		case "integer":
-		case "float":
-			type = "number";
-			break;
-		case "date":
-		case "datetime":
-			usedUtilityTypes.Timestamp = true;
-			type = "Timestamp";
-			break;
-		case "bool":
-		case "boolean":
-			type = "boolean";
-			break;
-		case "enum":
-			type = getEnumType(fieldConfig);
-			break;
-		case "nested": return getNestedType(fieldConfig);
-		default:
-			type = "string";
-			break;
-	}
-	return {
-		type,
-		usedUtilityTypes
-	};
-}
-/**
-* Generate the complete field type including array and null modifiers.
-* @param fieldConfig - The field configuration
-* @returns The complete field type with used utility types
-*/
-function generateFieldType(fieldConfig) {
-	const baseTypeResult = getBaseType(fieldConfig);
-	const usedUtilityTypes = { ...baseTypeResult.usedUtilityTypes };
-	const isArray = fieldConfig.array === true;
-	const isNullable = fieldConfig.required !== true;
-	const isColumnTypeBase = (/* @__PURE__ */ new Set(["Timestamp"])).has(baseTypeResult.type);
-	let finalType = baseTypeResult.type;
-	if (isArray) if (isColumnTypeBase || finalType.startsWith("ObjectColumnType<")) finalType = `ArrayColumnType<${baseTypeResult.type}>`;
-	else finalType = fieldConfig.type === "enum" ? `(${baseTypeResult.type})[]` : `${baseTypeResult.type}[]`;
-	if (isNullable) finalType = `${finalType} | null`;
-	if (fieldConfig.serial) {
-		usedUtilityTypes.Serial = true;
-		finalType = `Serial<${finalType}>`;
-	}
-	if (fieldConfig.hooks?.create || fieldConfig.default !== void 0) finalType = `Generated<${finalType}>`;
-	return {
-		type: finalType,
-		usedUtilityTypes
-	};
-}
-/**
-* Generate the table interface.
-* @param type - The parsed TailorDB type
-* @returns The type definition and used utility types
-*/
-function generateTableInterface(type) {
-	const fieldResults = Object.entries(type.fields).filter(([fieldName]) => fieldName !== "id").map(([fieldName, parsedField]) => ({
-		fieldName,
-		...generateFieldType(parsedField.config)
-	}));
-	const fields = ["id: Generated<string>;", ...fieldResults.map((result) => `${result.fieldName}: ${result.type};`)];
-	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
-		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || result.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	return {
-		typeDef: multiline`
-    ${type.name}: {
-      ${fields.join("\n")}
-    }
-  `,
-		usedUtilityTypes: aggregatedUtilityTypes
-	};
-}
-/**
-* Convert a TailorDBType into KyselyTypeMetadata.
-* @param type - Parsed TailorDB type
-* @returns Generated Kysely type metadata
-*/
-async function processKyselyType(type) {
-	const result = generateTableInterface(type);
-	return {
-		name: type.name,
-		typeDef: result.typeDef,
-		usedUtilityTypes: result.usedUtilityTypes
-	};
-}
-/**
-* Generate unified types file from multiple namespaces.
-* @param namespaceData - Namespace metadata
-* @returns Generated types file contents
-*/
-function generateUnifiedKyselyTypes(namespaceData) {
-	if (namespaceData.length === 0) return "";
-	const globalUsedUtilityTypes = namespaceData.reduce((acc, ns) => ({
-		Timestamp: acc.Timestamp || ns.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || ns.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	const utilityTypeImports = ["type Generated"];
-	if (globalUsedUtilityTypes.Timestamp) utilityTypeImports.push("type Timestamp");
-	if (namespaceData.some((ns) => ns.types.some((t) => t.typeDef.includes("ObjectColumnType<")))) utilityTypeImports.push("type ObjectColumnType");
-	if (namespaceData.some((ns) => ns.types.some((t) => t.typeDef.includes("ArrayColumnType<")))) utilityTypeImports.push("type ArrayColumnType");
-	if (globalUsedUtilityTypes.Serial) utilityTypeImports.push("type Serial");
-	return [
-		multiline`
-    import {
-      createGetDB,
-      ${utilityTypeImports.join(",\n")},
-      type NamespaceDB,
-      type NamespaceInsertable,
-      type NamespaceSelectable,
-      type NamespaceTable,
-      type NamespaceTableName,
-      type NamespaceTransaction,
-      type NamespaceUpdateable,
-    } from "@tailor-platform/sdk/kysely";
-  `,
-		`export interface Namespace {\n${namespaceData.map(({ namespace, types }) => {
-			return `  "${namespace}": {\n${types.map((type) => {
-				return type.typeDef.split("\n").map((line) => line.trim() ? `    ${line}` : "").join("\n");
-			}).join("\n\n")}\n  }`;
-		}).join(",\n")}\n}`,
-		multiline`
-    export const getDB = createGetDB<Namespace>();
-
-    export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
-  `,
-		multiline`
-    export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
-      NamespaceTransaction<Namespace, K>;
-
-    type TableName = NamespaceTableName<Namespace>;
-    export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
-
-    export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
-    export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
-    export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;
-  `
-	].join("\n\n") + "\n";
-}
-
-//#endregion
-//#region src/plugin/builtin/kysely-type/index.ts
-/** Unique identifier for the Kysely type generator plugin. */
-const KyselyGeneratorID = "@tailor-platform/kysely-type";
-/**
-* Plugin that generates Kysely type definitions for TailorDB types.
-* @param options - Plugin options
-* @param options.distPath - Output file path for generated types
-* @returns Plugin instance with onTailorDBReady hook
-*/
-function kyselyTypePlugin(options) {
-	return {
-		id: KyselyGeneratorID,
-		description: "Generates Kysely type definitions for TailorDB types",
-		pluginConfig: options,
-		async onTailorDBReady(ctx) {
-			const allNamespaceData = [];
-			for (const ns of ctx.tailordb) {
-				const typeMetadataList = [];
-				for (const type of Object.values(ns.types)) {
-					const metadata = await processKyselyType(type);
-					typeMetadataList.push(metadata);
-				}
-				if (typeMetadataList.length === 0) continue;
-				const usedUtilityTypes = typeMetadataList.reduce((acc, type) => ({
-					Timestamp: acc.Timestamp || type.usedUtilityTypes.Timestamp,
-					Serial: acc.Serial || type.usedUtilityTypes.Serial
-				}), {
-					Timestamp: false,
-					Serial: false
-				});
-				allNamespaceData.push({
-					namespace: ns.namespace,
-					types: typeMetadataList,
-					usedUtilityTypes
-				});
-			}
-			const files = [];
-			if (allNamespaceData.length > 0) {
-				const content = generateUnifiedKyselyTypes(allNamespaceData);
-				files.push({
-					path: ctx.pluginConfig.distPath,
-					content
-				});
-			}
-			return { files };
-		}
-	};
-}
-
-//#endregion
-export { KyselyGeneratorID, kyselyTypePlugin };
-//# sourceMappingURL=index.mjs.map
+import{n as e,r as t,t as n}from"../../../kysely-type-BTi3BMtL.mjs";export{n as DEFAULT_KYSELY_TYPES_DIST_PATH,e as KyselyGeneratorID,t as kyselyTypePlugin};

package/dist/plugin/builtin/seed/index.d.mts

@@ -32,6 +32,11 @@ type SeedPluginOptions = {
    */
   disableIdpUserSync?: DisableIdpUserSyncDirections;
 };
+declare module "@tailor-platform/sdk/plugin" {
+  interface PluginConfigRegistry {
+    "@tailor-platform/seed": SeedPluginOptions;
+  }
+}
 /**
  * Plugin that generates seed data and schema files consumed by the
  * `tailor seed` commands (@tailor-platform/sdk-plugin-seed).

package/dist/plugin/builtin/seed/index.mjs

@@ -1,3 +1 @@
-import { n as seedPlugin, t as SeedGeneratorID } from "../../../seed-xqM9WIHP.mjs";
-
-export { SeedGeneratorID, seedPlugin };
+import{n as e,t}from"../../../seed-DwqRFdqP.mjs";export{t as SeedGeneratorID,e as seedPlugin};

package/dist/plugin/builtin/seed/seed-type-processor.d.mts

@@ -1,6 +1,4 @@
-import "../../../parser/service/tailordb/types.mjs";
 import "../../types.mjs";
-import "./types.mjs";
 //#region src/plugin/builtin/seed/seed-type-processor.d.ts
 /**
  * Seed ordering information for a TailorDB namespace.
@@ -8,13 +6,13 @@ import "./types.mjs";
 interface SeedNamespaceConfig {
   /** TailorDB namespace name. */
   namespace: string;
-  /** Type names in the namespace, in definition order. */
+  /** Table names in the namespace, in definition order. */
   types: string[];
-  /** Seed dependencies (referenced type names) per type. */
+  /** Seed dependencies (referenced table names) per table. */
   dependencies: Record<string, string[]>;
-  /** Types with self-referencing fields, seeded in two passes. */
+  /** Tables with self-referencing fields, seeded in two passes. */
   selfRefTypes: string[];
-  /** Field names a seed row must supply per type, enforced with `--upsert`. */
+  /** Field names a seed row must supply per table, enforced with `--upsert`. */
   requiredFields: Record<string, string[]>;
 }
 //#endregion

package/dist/plugin/get-generated-table.d.mts

@@ -0,0 +1,16 @@
+import { TailorAnyDBType } from "../configure/services/tailordb/types.mjs";
+//#region src/plugin/get-generated-table.d.ts
+/**
+ * Get a generated table from a plugin by loading the config and resolving everything automatically.
+ * For table-attached plugins, calls onTableLoaded() with the source table.
+ * For namespace plugins, calls onNamespaceLoaded() with auto-resolved namespace.
+ * Results are cached per config path, plugin, namespace, and pluginConfig to avoid redundant processing.
+ * @param configPath - Path to tailor.config.ts (absolute or relative to cwd)
+ * @param pluginId - The plugin's unique identifier
+ * @param sourceTable - The source TailorDB table (null for namespace plugins)
+ * @param kind - The generated table kind (e.g., "request", "step")
+ * @returns The generated TailorDB table
+ */
+declare function getGeneratedTable(configPath: string, pluginId: string, sourceTable: TailorAnyDBType | null, kind: string): Promise<TailorAnyDBType>;
+//#endregion
+export { getGeneratedTable };

package/dist/plugin/index.d.mts

@@ -1,3 +1,4 @@
+import { PluginConfigRegistry } from "./types.mjs";
 import { PluginDBSchema, PluginExecutorFactory, PluginFunctionArgs, PluginRecord, PluginRecordCreatedArgs, PluginRecordDeletedArgs, PluginRecordUpdatedArgs, withPluginContext } from "./with-context.mjs";
-import { getGeneratedType } from "./get-generated-type.mjs";
-export { type PluginDBSchema, type PluginExecutorFactory, type PluginFunctionArgs, type PluginRecord, type PluginRecordCreatedArgs, type PluginRecordDeletedArgs, type PluginRecordUpdatedArgs, getGeneratedType, withPluginContext };
+import { getGeneratedTable } from "./get-generated-table.mjs";
+export { type PluginConfigRegistry, type PluginDBSchema, type PluginExecutorFactory, type PluginFunctionArgs, type PluginRecord, type PluginRecordCreatedArgs, type PluginRecordDeletedArgs, type PluginRecordUpdatedArgs, getGeneratedTable, withPluginContext };

package/dist/plugin/index.mjs

@@ -1,252 +1,2 @@
-import * as path from "pathe";
-import * as fs from "node:fs";
-import { pathToFileURL } from "node:url";
-
-//#region src/plugin/with-context.ts
-/**
-* Define a plugin executor that receives context at runtime.
-* This allows executor definitions to be in separate files while
-* still receiving dynamic values like typeName, generated types, and namespace.
-* @param factory - Function that takes context and returns executor configuration
-* @returns The same factory function (for type inference)
-* @example
-* ```typescript
-* // executors/on-create.ts
-* import { withPluginContext } from "@tailor-platform/sdk/plugin";
-* import { createExecutor, recordCreatedTrigger } from "@tailor-platform/sdk";
-* import { getDB } from "@tailor-platform/function-kysely-tailordb";
-*
-* interface MyContext {
-*   sourceType: TailorAnyDBType;
-*   historyType: TailorAnyDBType;
-*   namespace: string;
-* }
-*
-* export default withPluginContext<MyContext>((ctx) =>
-*   createExecutor({
-*     name: `${ctx.sourceType.name.toLowerCase()}-on-create`,
-*     trigger: recordCreatedTrigger({ type: ctx.sourceType }),
-*     operation: {
-*       kind: "function",
-*       body: async (args) => {
-*         const db = getDB(ctx.namespace);
-*         await db.insertInto(ctx.historyType.name).values({
-*           recordId: args.newRecord.id,
-*           // ...
-*         }).execute();
-*       },
-*     },
-*   })
-* );
-* ```
-*/
-function withPluginContext(factory) {
-	return factory;
-}
-
-//#endregion
-//#region src/plugin/get-generated-type.ts
-/** Cache: resolved config path -> loaded config data */
-const configCacheMap = /* @__PURE__ */ new Map();
-/**
-* Check if a value is a Plugin instance.
-* @param value - Value to check
-* @returns True if value has the shape of Plugin
-*/
-function isPlugin(value) {
-	return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.description === "string";
-}
-/**
-* Load and cache config module from the given path.
-* Extracts plugins from all array exports using definePlugins() format.
-* Returns null if the config file does not exist (e.g., in bundled executor on platform server).
-* @param configPath - Absolute or relative path to tailor.config.ts
-* @returns Cached config data with plugins map, or null if config file is not available
-*/
-async function loadAndCacheConfig(configPath) {
-	const resolvedPath = path.resolve(configPath);
-	const cached = configCacheMap.get(resolvedPath);
-	if (cached) return cached;
-	if (!fs.existsSync(resolvedPath)) return null;
-	const configModule = await import(pathToFileURL(resolvedPath).href);
-	if (!configModule?.default) throw new Error(`Invalid config module at "${resolvedPath}": default export not found`);
-	const config = configModule.default;
-	const configDir = path.dirname(resolvedPath);
-	const plugins = /* @__PURE__ */ new Map();
-	for (const value of Object.values(configModule)) {
-		if (!Array.isArray(value)) continue;
-		for (const item of value) if (isPlugin(item)) plugins.set(item.id, {
-			plugin: item,
-			pluginConfig: item.pluginConfig
-		});
-	}
-	const result = {
-		config,
-		plugins,
-		configDir
-	};
-	configCacheMap.set(resolvedPath, result);
-	return result;
-}
-/**
-* Resolve the namespace for a type-attached sourceType by checking config.db file patterns.
-* Uses ESM module cache identity: same file path yields same object references.
-* @param config - App config with db namespace definitions
-* @param config.db - DB namespace definitions
-* @param configDir - Directory containing the config file
-* @param sourceType - The TailorDB type to look up
-* @returns The namespace name
-*/
-async function resolveNamespaceForType(config, configDir, sourceType) {
-	if (!config.db) throw new Error(`No db configuration found in config`);
-	for (const [namespace, nsConfig] of Object.entries(config.db)) {
-		const dbConfig = nsConfig;
-		if (dbConfig.external || !dbConfig.files) continue;
-		for (const pattern of dbConfig.files) {
-			const absolutePattern = path.resolve(configDir, pattern);
-			let matchedFiles;
-			try {
-				matchedFiles = fs.globSync(absolutePattern);
-			} catch {
-				continue;
-			}
-			for (const file of matchedFiles) {
-				const mod = await import(pathToFileURL(file).href);
-				for (const exported of Object.values(mod)) if (exported === sourceType) return namespace;
-			}
-		}
-	}
-	throw new Error(`Could not resolve namespace for type "${sourceType.name}". Ensure the type file is included in a db namespace's files pattern.`);
-}
-/**
-* Resolve the namespace for a namespace plugin by trying each namespace.
-* Calls onNamespaceLoaded() for each and returns the first whose output contains the requested kind.
-* @param config - App config with db namespace definitions
-* @param config.db - DB namespace definitions
-* @param plugin - Plugin instance
-* @param kind - The generated type kind to look for
-* @param pluginConfig - Plugin-level configuration
-* @returns The namespace name
-*/
-async function resolveNamespaceForNamespacePlugin(config, plugin, kind, pluginConfig) {
-	if (!config.db) throw new Error(`No db configuration found in config`);
-	if (!plugin.onNamespaceLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onNamespaceLoaded() method`);
-	for (const namespace of Object.keys(config.db)) {
-		if (config.db[namespace].external) continue;
-		const output = await plugin.onNamespaceLoaded({
-			pluginConfig,
-			namespace
-		});
-		if (output.types?.[kind]) return {
-			namespace,
-			output
-		};
-	}
-	throw new Error(`Could not resolve namespace for plugin "${plugin.id}" with kind "${kind}". No namespace produced a type with that kind.`);
-}
-const processCache = /* @__PURE__ */ new WeakMap();
-const namespaceProcessCache = /* @__PURE__ */ new WeakMap();
-/**
-* Generate a cache key that includes pluginConfig.
-* @param baseKey - Base key for the cache
-* @param pluginConfig - Plugin configuration to include in the key
-* @returns Cache key string
-*/
-function getCacheKey(baseKey, pluginConfig) {
-	if (pluginConfig === void 0) return baseKey;
-	try {
-		return `${baseKey}:${JSON.stringify(pluginConfig)}`;
-	} catch {
-		throw new Error(`pluginConfig must be JSON-serializable for caching. Received non-serializable value.`);
-	}
-}
-/**
-* Get a generated type from a plugin by loading the config and resolving everything automatically.
-* For type-attached plugins, calls onTypeLoaded() with the sourceType.
-* For namespace plugins, calls onNamespaceLoaded() with auto-resolved namespace.
-* Results are cached per config path, plugin, namespace, and pluginConfig to avoid redundant processing.
-* @param configPath - Path to tailor.config.ts (absolute or relative to cwd)
-* @param pluginId - The plugin's unique identifier
-* @param sourceType - The source TailorDB type (null for namespace plugins)
-* @param kind - The generated type kind (e.g., "request", "step")
-* @returns The generated TailorDB type
-*/
-async function getGeneratedType(configPath, pluginId, sourceType, kind) {
-	const cache = await loadAndCacheConfig(configPath);
-	if (!cache) return {
-		name: `__placeholder_${kind}__`,
-		fields: {}
-	};
-	const { config, configDir, plugins } = cache;
-	const pluginEntry = plugins.get(pluginId);
-	if (!pluginEntry) throw new Error(`Plugin "${pluginId}" not found in config at "${configPath}". Ensure the plugin is registered via definePlugins().`);
-	const { plugin, pluginConfig } = pluginEntry;
-	if (sourceType === null) return getGeneratedTypeForNamespacePlugin(config, plugin, kind, pluginConfig);
-	return getGeneratedTypeForTypeAttachedPlugin(plugin, sourceType, kind, pluginConfig, await resolveNamespaceForType(config, configDir, sourceType));
-}
-/**
-* Get a generated type from a type-attached plugin.
-* @param plugin - The plugin instance (must have onTypeLoaded() method)
-* @param sourceType - The source TailorDB type
-* @param kind - The generated type kind
-* @param pluginConfig - Plugin-level configuration
-* @param namespace - Resolved namespace
-* @returns The generated TailorDB type
-*/
-async function getGeneratedTypeForTypeAttachedPlugin(plugin, sourceType, kind, pluginConfig, namespace) {
-	if (!plugin.onTypeLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onTypeLoaded() method`);
-	let pluginCache = processCache.get(plugin);
-	if (!pluginCache) {
-		pluginCache = /* @__PURE__ */ new Map();
-		processCache.set(plugin, pluginCache);
-	}
-	const cacheKey = getCacheKey(`${sourceType.name}:ns=${namespace}`, pluginConfig);
-	let output = pluginCache.get(cacheKey);
-	if (!output) {
-		const typeConfig = sourceType.plugins.find((p) => p.pluginId === plugin.id)?.config;
-		output = await plugin.onTypeLoaded({
-			type: sourceType,
-			typeConfig: typeConfig ?? {},
-			pluginConfig,
-			namespace
-		});
-		pluginCache.set(cacheKey, output);
-	}
-	const generatedType = output.types?.[kind];
-	if (!generatedType) throw new Error(`Generated type not found: plugin=${plugin.id}, sourceType=${sourceType.name}, kind=${kind}`);
-	return generatedType;
-}
-/**
-* Get a generated type from a namespace plugin.
-* Auto-resolves the namespace by trying each one.
-* @param config - App config with db namespace definitions
-* @param config.db - DB namespace definitions
-* @param plugin - The plugin instance (must have onNamespaceLoaded() method)
-* @param kind - The generated type kind
-* @param pluginConfig - Plugin-level configuration
-* @returns The generated TailorDB type
-*/
-async function getGeneratedTypeForNamespacePlugin(config, plugin, kind, pluginConfig) {
-	if (!plugin.onNamespaceLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onNamespaceLoaded() method`);
-	let pluginCache = namespaceProcessCache.get(plugin);
-	if (!pluginCache) {
-		pluginCache = /* @__PURE__ */ new Map();
-		namespaceProcessCache.set(plugin, pluginCache);
-	}
-	if (config.db) for (const namespace of Object.keys(config.db)) {
-		if (config.db[namespace].external) continue;
-		const cacheKey = getCacheKey(`namespace:ns=${namespace}`, pluginConfig);
-		const cached = pluginCache.get(cacheKey);
-		if (cached?.types?.[kind]) return cached.types[kind];
-	}
-	const { namespace, output } = await resolveNamespaceForNamespacePlugin(config, plugin, kind, pluginConfig);
-	const cacheKey = getCacheKey(`namespace:ns=${namespace}`, pluginConfig);
-	pluginCache.set(cacheKey, output);
-	const generatedType = output.types?.[kind];
-	if (!generatedType) throw new Error(`Generated type not found: plugin=${plugin.id}, kind=${kind}`);
-	return generatedType;
-}
-
-//#endregion
-export { getGeneratedType, withPluginContext };
+import*as e from"pathe";import*as t from"node:fs";import{pathToFileURL as n}from"node:url";function withPluginContext(e){return e}const r=new Map;function isPlugin(e){return typeof e==`object`&&!!e&&typeof e.id==`string`&&typeof e.description==`string`}async function loadAndCacheConfig(i){let a=e.resolve(i),o=r.get(a);if(o)return o;if(!t.existsSync(a))return null;let s=await import(n(a).href);if(!s?.default)throw Error(`Invalid config module at "${a}": default export not found`);let c=s.default,l=e.dirname(a),u=new Map;for(let e of Object.values(s))if(Array.isArray(e))for(let t of e)isPlugin(t)&&u.set(t.id,{plugin:t,pluginConfig:t.pluginConfig});let d={config:c,plugins:u,configDir:l};return r.set(a,d),d}async function resolveNamespaceForTable(r,i,a){if(!r.db)throw Error(`No db configuration found in config`);for(let[o,s]of Object.entries(r.db)){let r=s;if(!(r.external||!r.files))for(let s of r.files){let r=e.resolve(i,s),c;try{c=t.globSync(r)}catch{continue}for(let e of c){let t=await import(n(e).href);for(let e of Object.values(t))if(e===a)return o}}}throw Error(`Could not resolve namespace for table "${a.name}". Ensure the table file is included in a db namespace's files pattern.`)}async function resolveNamespaceForNamespacePlugin(e,t,n,r){if(!e.db)throw Error(`No db configuration found in config`);if(!t.onNamespaceLoaded)throw Error(`Plugin "${t.id}" does not have a onNamespaceLoaded() method`);for(let i of Object.keys(e.db)){if(e.db[i].external)continue;let a=await t.onNamespaceLoaded({pluginConfig:r,namespace:i});if(a.tables?.[n])return{namespace:i,output:a}}throw Error(`Could not resolve namespace for plugin "${t.id}" with kind "${n}". No namespace produced a table with that kind.`)}const i=new WeakMap,a=new WeakMap;function getCacheKey(e,t){if(t===void 0)return e;try{return`${e}:${JSON.stringify(t)}`}catch{throw Error(`pluginConfig must be JSON-serializable for caching. Received non-serializable value.`)}}async function getGeneratedTable(e,t,n,r){let i=await loadAndCacheConfig(e);if(!i)return{name:`__placeholder_${r}__`,fields:{}};let{config:a,configDir:o,plugins:s}=i,c=s.get(t);if(!c)throw Error(`Plugin "${t}" not found in config at "${e}". Ensure the plugin is registered via definePlugins().`);let{plugin:l,pluginConfig:u}=c;return n===null?getGeneratedTableForNamespacePlugin(a,l,r,u):getGeneratedTableForTableAttachedPlugin(l,n,r,u,await resolveNamespaceForTable(a,o,n))}async function getGeneratedTableForTableAttachedPlugin(e,t,n,r,a){if(!e.onTableLoaded)throw Error(`Plugin "${e.id}" does not have an onTableLoaded() method`);let o=i.get(e);o||(o=new Map,i.set(e,o));let s=getCacheKey(`${t.name}:ns=${a}`,r),c=o.get(s);if(!c){let n=t.plugins.find(t=>t.pluginId===e.id)?.config;c=await e.onTableLoaded({table:t,tableConfig:n??{},pluginConfig:r,namespace:a}),o.set(s,c)}let l=c.tables?.[n];if(!l)throw Error(`Generated table not found: plugin=${e.id}, sourceTable=${t.name}, kind=${n}`);return l}async function getGeneratedTableForNamespacePlugin(e,t,n,r){if(!t.onNamespaceLoaded)throw Error(`Plugin "${t.id}" does not have a onNamespaceLoaded() method`);let i=a.get(t);if(i||(i=new Map,a.set(t,i)),e.db)for(let t of Object.keys(e.db)){if(e.db[t].external)continue;let a=getCacheKey(`namespace:ns=${t}`,r),o=i.get(a);if(o?.tables?.[n])return o.tables[n]}let{namespace:o,output:s}=await resolveNamespaceForNamespacePlugin(e,t,n,r),c=getCacheKey(`namespace:ns=${o}`,r);i.set(c,s);let l=s.tables?.[n];if(!l)throw Error(`Generated table not found: plugin=${t.id}, kind=${n}`);return l}export{getGeneratedTable,withPluginContext};
 //# sourceMappingURL=index.mjs.map