@happyvertical/smrt-core 0.30.0

package/dist/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sources":["../src/database.ts"],"sourcesContent":["/**\n * Database configuration and resolution utilities\n *\n * This module provides a unified type for database configuration options\n * and a utility function to resolve any config format to a DatabaseInterface.\n *\n * @module\n */\n\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { getDatabase } from '@happyvertical/sql';\n\n/**\n * Unified type for all database configuration formats\n *\n * Supports three formats:\n * - **String**: Connection URL (e.g., 'products.db', ':memory:', 'postgres://...')\n * - **Config object**: Full configuration with type, url, and options\n * - **DatabaseInterface**: Pre-initialized database instance\n *\n * @example\n * ```typescript\n * // String shortcut\n * const config: DatabaseConfig = 'products.db';\n *\n * // Config object\n * const config: DatabaseConfig = {\n *   type: 'sqlite',\n *   url: 'products.db',\n *   authToken: 'token'\n * };\n *\n * // Pre-initialized instance\n * const db = await getDatabase({ type: 'sqlite', url: ':memory:' });\n * const config: DatabaseConfig = db;\n * ```\n */\nexport type DatabaseConfig =\n  | string\n  | {\n      url?: string;\n      type?: 'sqlite' | 'postgres' | 'duckdb' | 'json';\n      authToken?: string;\n      [key: string]: any;\n    }\n  | DatabaseInterface;\n\n/**\n * Type guard to check if a value is a DatabaseInterface instance\n *\n * @param value - Value to check\n * @returns True if value has query() and close() methods\n *\n * @example\n * ```typescript\n * if (isDatabaseInterface(config)) {\n *   // config is DatabaseInterface\n *   await config.query('SELECT 1');\n * }\n * ```\n */\nexport function isDatabaseInterface(\n  value: unknown,\n): value is DatabaseInterface {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    'query' in value &&\n    typeof (value as any).query === 'function'\n  );\n}\n\n/**\n * Options for resolving a database configuration\n */\nexport interface ResolveDatabaseOptions {\n  /**\n   * Cache key for connection pooling.\n   * If provided, the same dbid returns the same cached connection.\n   */\n  dbid?: string;\n\n  /**\n   * Optional pre-generated schemas to pass to the database adapter.\n   *\n   * Intended for explicit tooling and test utilities that bootstrap schema\n   * ahead of runtime. Core runtime no longer passes these automatically.\n   */\n  schemas?: Record<string, any>;\n}\n\n/**\n * Resolve any DatabaseConfig format to a DatabaseInterface instance\n *\n * This utility function normalizes the three config formats:\n * 1. **String URL**: Passed to getDatabase() with auto-detected type\n * 2. **Config object**: Passed to getDatabase() directly\n * 3. **DatabaseInterface**: Returned as-is\n *\n * @param config - Database configuration in any supported format\n * @param options - Resolution options (dbid for caching, optional explicit schemas)\n * @returns Promise resolving to a DatabaseInterface instance\n *\n * @example\n * ```typescript\n * // String URL\n * const db = await resolveDatabase('products.db');\n *\n * // Config object\n * const db = await resolveDatabase({\n *   type: 'postgres',\n *   url: 'postgres://localhost/mydb'\n * });\n *\n * // Pre-initialized instance (returned as-is)\n * const existingDb = await getDatabase({ url: ':memory:' });\n * const db = await resolveDatabase(existingDb);\n * console.log(db === existingDb); // true\n * ```\n */\nexport async function resolveDatabase(\n  config: DatabaseConfig,\n  options: ResolveDatabaseOptions = {},\n): Promise<DatabaseInterface> {\n  const { dbid, schemas } = options;\n\n  // Already a DatabaseInterface instance - return as-is\n  if (isDatabaseInterface(config)) {\n    return config;\n  }\n\n  // String URL shortcut\n  if (typeof config === 'string') {\n    const isMemoryDb = config === ':memory:';\n    return getDatabase({\n      url: config,\n      schemas,\n      ...(isMemoryDb ? {} : { dbid: dbid ?? `smrt:${config}` }),\n    });\n  }\n\n  // Config object\n  // Only default to :memory: for SQLite (or unspecified type which defaults to SQLite)\n  // Other adapters (json, postgres, duckdb) require explicit URLs\n  const canUseMemory = !config.type || config.type === 'sqlite';\n  const dbUrl = config.url || (canUseMemory ? ':memory:' : '');\n  const isMemoryDb = dbUrl === ':memory:';\n  return getDatabase({\n    ...config,\n    url: dbUrl,\n    schemas,\n    ...(isMemoryDb ? {} : { dbid: dbid ?? `smrt:${dbUrl}` }),\n  } as any);\n}\n"],"names":["isMemoryDb"],"mappings":";AA6DO,SAAS,oBACd,OAC4B;AAC5B,SACE,UAAU,QACV,OAAO,UAAU,YACjB,WAAW,SACX,OAAQ,MAAc,UAAU;AAEpC;AAkDA,eAAsB,gBACpB,QACA,UAAkC,IACN;AAC5B,QAAM,EAAE,MAAM,QAAA,IAAY;AAG1B,MAAI,oBAAoB,MAAM,GAAG;AAC/B,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,WAAW,UAAU;AAC9B,UAAMA,cAAa,WAAW;AAC9B,WAAO,YAAY;AAAA,MACjB,KAAK;AAAA,MACL;AAAA,MACA,GAAIA,cAAa,CAAA,IAAK,EAAE,MAAM,QAAQ,QAAQ,MAAM,GAAA;AAAA,IAAG,CACxD;AAAA,EACH;AAKA,QAAM,eAAe,CAAC,OAAO,QAAQ,OAAO,SAAS;AACrD,QAAM,QAAQ,OAAO,QAAQ,eAAe,aAAa;AACzD,QAAM,aAAa,UAAU;AAC7B,SAAO,YAAY;AAAA,IACjB,GAAG;AAAA,IACH,KAAK;AAAA,IACL;AAAA,IACA,GAAI,aAAa,CAAA,IAAK,EAAE,MAAM,QAAQ,QAAQ,KAAK,GAAA;AAAA,EAAG,CAChD;AACV;"}

package/dist/decorators/compatibility.d.ts

@@ -0,0 +1,14 @@
+export type LegacyPropertyDecoratorTarget = {
+    constructor?: Function & {
+        name?: string;
+    };
+};
+export type CompatiblePropertyDecoratorContext<This, Value> = string | symbol | ClassFieldDecoratorContext<This, Value>;
+export interface CompatiblePropertyDecorator<This = any, Value = any> {
+    (target: object, propertyKey: string | symbol): void;
+    (value: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
+}
+export declare function resolveDecoratorClassName(target: unknown): string | undefined;
+export declare function applyPendingDecoratorRegistrations(target: Function, decoratorContext?: ClassDecoratorContext): void;
+export declare function registerCompatibleFieldDecorator<This, Value>(targetOrValue: LegacyPropertyDecoratorTarget | undefined, propertyKeyOrContext: CompatiblePropertyDecoratorContext<This, Value>, registerFieldDecorator: (className: string, propertyKey: string) => void): void;
+//# sourceMappingURL=compatibility.d.ts.map

package/dist/decorators/compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../src/decorators/compatibility.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,WAAW,CAAC,EAAE,QAAQ,GAAG;QACvB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,kCAAkC,CAAC,IAAI,EAAE,KAAK,IACtD,MAAM,GACN,MAAM,GACN,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAE5C,MAAM,WAAW,2BAA2B,CAAC,IAAI,GAAG,GAAG,EAAE,KAAK,GAAG,GAAG;IAClE,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACrD,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;CAC5E;AA2FD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU7E;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,QAAQ,EAChB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,IAAI,CAsBN;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,KAAK,EAC1D,aAAa,EAAE,6BAA6B,GAAG,SAAS,EACxD,oBAAoB,EAAE,kCAAkC,CAAC,IAAI,EAAE,KAAK,CAAC,EACrE,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GACvE,IAAI,CAiCN"}

package/dist/decorators/compatibility.js

@@ -0,0 +1,111 @@
+const PENDING_FIELD_DECORATORS_KEY = /* @__PURE__ */ Symbol.for(
+  "@happyvertical/smrt-core/pending-field-decorators"
+);
+const standardDecoratorRegistrations = /* @__PURE__ */ new WeakMap();
+function getDecoratorConstructor(target) {
+  if (typeof target === "function") {
+    return target;
+  }
+  if (target && typeof target === "object") {
+    return target.constructor;
+  }
+  return void 0;
+}
+function markStandardDecoratorRegistration(target, register) {
+  const ctor = getDecoratorConstructor(target);
+  if (!ctor) {
+    return false;
+  }
+  const registeredCallbacks = standardDecoratorRegistrations.get(ctor) ?? /* @__PURE__ */ new WeakSet();
+  if (registeredCallbacks.has(register)) {
+    return false;
+  }
+  registeredCallbacks.add(register);
+  standardDecoratorRegistrations.set(ctor, registeredCallbacks);
+  return true;
+}
+function getDecoratorMetadata(contextOrMetadata) {
+  if (!contextOrMetadata || typeof contextOrMetadata !== "object") {
+    return void 0;
+  }
+  if ("metadata" in contextOrMetadata) {
+    const { metadata } = contextOrMetadata;
+    return metadata && typeof metadata === "object" ? metadata : void 0;
+  }
+  return contextOrMetadata;
+}
+function getClassDecoratorMetadata(target, decoratorContext) {
+  const metadataFromContext = getDecoratorMetadata(decoratorContext);
+  if (metadataFromContext) {
+    return metadataFromContext;
+  }
+  const metadataSymbol = Symbol.metadata;
+  if (!metadataSymbol) {
+    return void 0;
+  }
+  const metadata = target[metadataSymbol];
+  return metadata && typeof metadata === "object" ? metadata : void 0;
+}
+function queuePendingFieldDecorator(metadata, register) {
+  const pendingDecorators = metadata[PENDING_FIELD_DECORATORS_KEY] ?? [];
+  pendingDecorators.push({ register });
+  metadata[PENDING_FIELD_DECORATORS_KEY] = pendingDecorators;
+}
+function resolveDecoratorClassName(target) {
+  if (typeof target === "function") {
+    return target.name;
+  }
+  if (target && typeof target === "object") {
+    return target.constructor?.name;
+  }
+  return void 0;
+}
+function applyPendingDecoratorRegistrations(target, decoratorContext) {
+  const metadata = getClassDecoratorMetadata(target, decoratorContext);
+  if (!metadata) {
+    return;
+  }
+  const pendingDecorators = metadata[PENDING_FIELD_DECORATORS_KEY];
+  if (!pendingDecorators || pendingDecorators.length === 0) {
+    return;
+  }
+  for (const { register } of pendingDecorators) {
+    if (!markStandardDecoratorRegistration(target, register)) {
+      continue;
+    }
+    register(target.name);
+  }
+  Reflect.deleteProperty(metadata, PENDING_FIELD_DECORATORS_KEY);
+}
+function registerCompatibleFieldDecorator(targetOrValue, propertyKeyOrContext, registerFieldDecorator) {
+  if (typeof propertyKeyOrContext === "string" || typeof propertyKeyOrContext === "symbol") {
+    const className = resolveDecoratorClassName(targetOrValue);
+    if (className) {
+      registerFieldDecorator(className, String(propertyKeyOrContext));
+    }
+    return;
+  }
+  const context = propertyKeyOrContext;
+  const propertyKey = String(context.name);
+  const register = (className) => registerFieldDecorator(className, propertyKey);
+  const metadata = getDecoratorMetadata(context);
+  if (metadata) {
+    queuePendingFieldDecorator(metadata, register);
+    return;
+  }
+  context.addInitializer?.(function registerSmrtDecorator() {
+    if (!markStandardDecoratorRegistration(this, register)) {
+      return;
+    }
+    const className = resolveDecoratorClassName(this);
+    if (className) {
+      register(className);
+    }
+  });
+}
+export {
+  applyPendingDecoratorRegistrations,
+  registerCompatibleFieldDecorator,
+  resolveDecoratorClassName
+};
+//# sourceMappingURL=compatibility.js.map

package/dist/decorators/compatibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.js","sources":["../../src/decorators/compatibility.ts"],"sourcesContent":["type DecoratorMetadataStore = Record<PropertyKey, unknown>;\n\nconst PENDING_FIELD_DECORATORS_KEY = Symbol.for(\n  '@happyvertical/smrt-core/pending-field-decorators',\n);\nconst standardDecoratorRegistrations = new WeakMap<\n  Function,\n  WeakSet<(className: string) => void>\n>();\n\ntype PendingDecoratorRegistration = {\n  register: (className: string) => void;\n};\n\nexport type LegacyPropertyDecoratorTarget = {\n  constructor?: Function & {\n    name?: string;\n  };\n};\n\nexport type CompatiblePropertyDecoratorContext<This, Value> =\n  | string\n  | symbol\n  | ClassFieldDecoratorContext<This, Value>;\n\nexport interface CompatiblePropertyDecorator<This = any, Value = any> {\n  (target: object, propertyKey: string | symbol): void;\n  (value: undefined, context: ClassFieldDecoratorContext<This, Value>): void;\n}\n\nfunction getDecoratorConstructor(target: unknown): Function | undefined {\n  if (typeof target === 'function') {\n    return target;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor;\n  }\n\n  return undefined;\n}\n\nfunction markStandardDecoratorRegistration(\n  target: unknown,\n  register: (className: string) => void,\n): boolean {\n  const ctor = getDecoratorConstructor(target);\n  if (!ctor) {\n    return false;\n  }\n\n  const registeredCallbacks =\n    standardDecoratorRegistrations.get(ctor) ?? new WeakSet();\n  if (registeredCallbacks.has(register)) {\n    return false;\n  }\n\n  registeredCallbacks.add(register);\n  standardDecoratorRegistrations.set(ctor, registeredCallbacks);\n  return true;\n}\n\nfunction getDecoratorMetadata(\n  contextOrMetadata:\n    | ClassFieldDecoratorContext<any, any>\n    | ClassDecoratorContext\n    | DecoratorMetadataStore\n    | undefined,\n): DecoratorMetadataStore | undefined {\n  if (!contextOrMetadata || typeof contextOrMetadata !== 'object') {\n    return undefined;\n  }\n\n  if ('metadata' in contextOrMetadata) {\n    const { metadata } = contextOrMetadata as {\n      metadata?: DecoratorMetadataStore;\n    };\n    return metadata && typeof metadata === 'object' ? metadata : undefined;\n  }\n\n  return contextOrMetadata;\n}\n\nfunction getClassDecoratorMetadata(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): DecoratorMetadataStore | undefined {\n  const metadataFromContext = getDecoratorMetadata(decoratorContext);\n  if (metadataFromContext) {\n    return metadataFromContext;\n  }\n\n  const metadataSymbol = (Symbol as typeof Symbol & { metadata?: symbol })\n    .metadata;\n  if (!metadataSymbol) {\n    return undefined;\n  }\n\n  const metadata = (target as unknown as Record<PropertyKey, unknown>)[\n    metadataSymbol\n  ];\n  return metadata && typeof metadata === 'object'\n    ? (metadata as DecoratorMetadataStore)\n    : undefined;\n}\n\nfunction queuePendingFieldDecorator(\n  metadata: DecoratorMetadataStore,\n  register: (className: string) => void,\n): void {\n  const pendingDecorators =\n    (metadata[PENDING_FIELD_DECORATORS_KEY] as\n      | PendingDecoratorRegistration[]\n      | undefined) ?? [];\n\n  pendingDecorators.push({ register });\n  metadata[PENDING_FIELD_DECORATORS_KEY] = pendingDecorators;\n}\n\nexport function resolveDecoratorClassName(target: unknown): string | undefined {\n  if (typeof target === 'function') {\n    return target.name;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor?.name;\n  }\n\n  return undefined;\n}\n\nexport function applyPendingDecoratorRegistrations(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): void {\n  const metadata = getClassDecoratorMetadata(target, decoratorContext);\n  if (!metadata) {\n    return;\n  }\n\n  const pendingDecorators = metadata[PENDING_FIELD_DECORATORS_KEY] as\n    | PendingDecoratorRegistration[]\n    | undefined;\n  if (!pendingDecorators || pendingDecorators.length === 0) {\n    return;\n  }\n\n  for (const { register } of pendingDecorators) {\n    if (!markStandardDecoratorRegistration(target, register)) {\n      continue;\n    }\n\n    register(target.name);\n  }\n\n  Reflect.deleteProperty(metadata, PENDING_FIELD_DECORATORS_KEY);\n}\n\nexport function registerCompatibleFieldDecorator<This, Value>(\n  targetOrValue: LegacyPropertyDecoratorTarget | undefined,\n  propertyKeyOrContext: CompatiblePropertyDecoratorContext<This, Value>,\n  registerFieldDecorator: (className: string, propertyKey: string) => void,\n): void {\n  if (\n    typeof propertyKeyOrContext === 'string' ||\n    typeof propertyKeyOrContext === 'symbol'\n  ) {\n    const className = resolveDecoratorClassName(targetOrValue);\n    if (className) {\n      registerFieldDecorator(className, String(propertyKeyOrContext));\n    }\n    return;\n  }\n\n  const context = propertyKeyOrContext;\n  const propertyKey = String(context.name);\n  const register = (className: string) =>\n    registerFieldDecorator(className, propertyKey);\n  const metadata = getDecoratorMetadata(context);\n\n  if (metadata) {\n    queuePendingFieldDecorator(metadata, register);\n    return;\n  }\n\n  context.addInitializer?.(function registerSmrtDecorator() {\n    if (!markStandardDecoratorRegistration(this, register)) {\n      return;\n    }\n\n    const className = resolveDecoratorClassName(this);\n    if (className) {\n      register(className);\n    }\n  });\n}\n"],"names":[],"mappings":"AAEA,MAAM,+BAA+B,uBAAO;AAAA,EAC1C;AACF;AACA,MAAM,qDAAqC,QAAA;AAyB3C,SAAS,wBAAwB,QAAuC;AACtE,MAAI,OAAO,WAAW,YAAY;AAChC,WAAO;AAAA,EACT;AAEA,MAAI,UAAU,OAAO,WAAW,UAAU;AACxC,WAAQ,OAAyC;AAAA,EACnD;AAEA,SAAO;AACT;AAEA,SAAS,kCACP,QACA,UACS;AACT,QAAM,OAAO,wBAAwB,MAAM;AAC3C,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,QAAM,sBACJ,+BAA+B,IAAI,IAAI,yBAAS,QAAA;AAClD,MAAI,oBAAoB,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,sBAAoB,IAAI,QAAQ;AAChC,iCAA+B,IAAI,MAAM,mBAAmB;AAC5D,SAAO;AACT;AAEA,SAAS,qBACP,mBAKoC;AACpC,MAAI,CAAC,qBAAqB,OAAO,sBAAsB,UAAU;AAC/D,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,mBAAmB;AACnC,UAAM,EAAE,aAAa;AAGrB,WAAO,YAAY,OAAO,aAAa,WAAW,WAAW;AAAA,EAC/D;AAEA,SAAO;AACT;AAEA,SAAS,0BACP,QACA,kBACoC;AACpC,QAAM,sBAAsB,qBAAqB,gBAAgB;AACjE,MAAI,qBAAqB;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,iBAAkB,OACrB;AACH,MAAI,CAAC,gBAAgB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,WAAY,OAChB,cACF;AACA,SAAO,YAAY,OAAO,aAAa,WAClC,WACD;AACN;AAEA,SAAS,2BACP,UACA,UACM;AACN,QAAM,oBACH,SAAS,4BAA4B,KAEpB,CAAA;AAEpB,oBAAkB,KAAK,EAAE,UAAU;AACnC,WAAS,4BAA4B,IAAI;AAC3C;AAEO,SAAS,0BAA0B,QAAqC;AAC7E,MAAI,OAAO,WAAW,YAAY;AAChC,WAAO,OAAO;AAAA,EAChB;AAEA,MAAI,UAAU,OAAO,WAAW,UAAU;AACxC,WAAQ,OAAyC,aAAa;AAAA,EAChE;AAEA,SAAO;AACT;AAEO,SAAS,mCACd,QACA,kBACM;AACN,QAAM,WAAW,0BAA0B,QAAQ,gBAAgB;AACnE,MAAI,CAAC,UAAU;AACb;AAAA,EACF;AAEA,QAAM,oBAAoB,SAAS,4BAA4B;AAG/D,MAAI,CAAC,qBAAqB,kBAAkB,WAAW,GAAG;AACxD;AAAA,EACF;AAEA,aAAW,EAAE,SAAA,KAAc,mBAAmB;AAC5C,QAAI,CAAC,kCAAkC,QAAQ,QAAQ,GAAG;AACxD;AAAA,IACF;AAEA,aAAS,OAAO,IAAI;AAAA,EACtB;AAEA,UAAQ,eAAe,UAAU,4BAA4B;AAC/D;AAEO,SAAS,iCACd,eACA,sBACA,wBACM;AACN,MACE,OAAO,yBAAyB,YAChC,OAAO,yBAAyB,UAChC;AACA,UAAM,YAAY,0BAA0B,aAAa;AACzD,QAAI,WAAW;AACb,6BAAuB,WAAW,OAAO,oBAAoB,CAAC;AAAA,IAChE;AACA;AAAA,EACF;AAEA,QAAM,UAAU;AAChB,QAAM,cAAc,OAAO,QAAQ,IAAI;AACvC,QAAM,WAAW,CAAC,cAChB,uBAAuB,WAAW,WAAW;AAC/C,QAAM,WAAW,qBAAqB,OAAO;AAE7C,MAAI,UAAU;AACZ,+BAA2B,UAAU,QAAQ;AAC7C;AAAA,EACF;AAEA,UAAQ,iBAAiB,SAAS,wBAAwB;AACxD,QAAI,CAAC,kCAAkC,MAAM,QAAQ,GAAG;AACtD;AAAA,IACF;AAEA,UAAM,YAAY,0BAA0B,IAAI;AAChD,QAAI,WAAW;AACb,eAAS,SAAS;AAAA,IACpB;AAAA,EACF,CAAC;AACH;"}

package/dist/decorators/index.d.ts

@@ -0,0 +1,381 @@
+import { SQLDataType } from '../schema/types.js';
+import { CompatiblePropertyDecorator } from './compatibility.js';
+/**
+ * Meta type wrapper for STI (Single Table Inheritance) meta fields
+ *
+ * Fields typed as Meta<T> are stored in the _meta_data JSONB column
+ * rather than as direct table columns. Used for child-specific fields
+ * in STI hierarchies.
+ *
+ * @example
+ * ```typescript
+ * @smrt({ tableStrategy: 'sti' })
+ * class Event extends SmrtObject {
+ *   title: string = '';
+ * }
+ *
+ * @smrt()
+ * class Meeting extends Event {
+ *   // Stored in _meta_data JSONB column
+ *   roomNumber: Meta<string> = '';
+ *   attendees: Meta<string[]> = [];
+ * }
+ * ```
+ */
+export type Meta<T> = T;
+/**
+ * Base field options
+ */
+export type PrimitiveFieldType = 'text' | 'integer' | 'decimal' | 'boolean' | 'datetime' | 'json';
+export type FieldType = PrimitiveFieldType | 'meta' | 'foreignKey' | 'crossPackageRef' | 'oneToMany' | 'manyToMany';
+export interface FieldOptions {
+    /** Explicit field type for runtime-only registration paths */
+    type?: FieldType;
+    /** Explicit SQL storage type when runtime and persistence contracts differ */
+    sqlType?: SQLDataType;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Default value for the field */
+    default?: any;
+    /** Whether the field is unique */
+    unique?: boolean;
+    /**
+     * When `true`, the schema emits a database index targeting this field.
+     *
+     * For regular (column-backed) fields the index is a plain column index.
+     * For `@meta()` fields stored inside `_meta_data` JSONB, the index targets
+     * the JSON path — `json_extract(_meta_data, '$.fieldName')` on SQLite,
+     * `(_meta_data->>'fieldName')` on Postgres — giving WHERE clauses on that
+     * meta key the same performance as a real column.
+     */
+    indexed?: boolean;
+    /** Whether the field is nullable */
+    nullable?: boolean;
+    /** Whether the field should be excluded from database */
+    transient?: boolean;
+    /**
+     * Marks the field as sensitive (e.g. API secrets, credentials, tax IDs).
+     *
+     * Sensitive fields are still persisted to the database, but the framework:
+     * - excludes them from `toPublicJSON()` (the serializer used by generated
+     *   REST/MCP/SvelteKit routes), so they never appear in API responses; and
+     * - rejects them as `where`-clause filter keys, closing the
+     *   `?secret[like]=...` value-probing oracle.
+     *
+     * Use this for any column that holds a secret value that must never be
+     * read back over a generated network surface.
+     */
+    sensitive?: boolean;
+    /**
+     * Marks the field as read-only over generated write surfaces.
+     *
+     * Read-only fields are stripped from the request body before
+     * `create`/`update` in generated REST/MCP/SvelteKit routes, so callers
+     * cannot mass-assign them. Server-side code can still set them directly.
+     */
+    readonly?: boolean;
+    /** Field description */
+    description?: string;
+    /**
+     * Controls whether the field is included in JSON exports.
+     * - `true`: Always exported (unless site explicitly excludes it)
+     * - `false`: Never exported (cannot be overridden by site config)
+     * - `undefined`: Uses site's fieldExportDefault setting
+     */
+    exported?: boolean;
+}
+/**
+ * Options for text fields
+ */
+export interface TextFieldOptions extends FieldOptions {
+    /** Minimum length for text fields */
+    minLength?: number;
+    /** Maximum length for text fields */
+    maxLength?: number;
+    /** Regex pattern for validation */
+    pattern?: RegExp | string;
+}
+/**
+ * Options for numeric fields
+ */
+export interface NumericFieldOptions extends FieldOptions {
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+}
+/**
+ * Options for relationship fields
+ */
+export interface RelationshipFieldOptions extends FieldOptions {
+    /** Related class name */
+    related?: string;
+    /** Foreign key field name */
+    foreignKey?: string;
+    /** Through table for many-to-many */
+    through?: string;
+    /** Relationship type */
+    type?: 'foreignKey' | 'crossPackageRef' | 'oneToMany' | 'manyToMany';
+}
+/**
+ * Options specific to cross-package references.
+ */
+export interface CrossPackageRefOptions extends Omit<RelationshipFieldOptions, 'related' | 'type'> {
+    /**
+     * Storage type for the referenced target id. Defaults to 'uuid'.
+     *
+     * Use 'text' only when the external target model declares
+     * `@smrt({ idType: 'text' })`.
+     */
+    idType?: 'uuid' | 'text';
+    /**
+     * When `true`, the framework verifies the referenced object exists at save time.
+     * Validation uses the target package's manifest (loaded on demand via
+     * `ObjectRegistry.ensureManifestLoaded()`), so this requires the target manifest
+     * to be discoverable at runtime.
+     *
+     * Empty/null values are always allowed (treated as "no reference set").
+     *
+     * Defaults to `false` — same behavior as a plain string field today.
+     */
+    validate?: boolean;
+}
+/**
+ * Marks a class property with validation constraints and metadata options.
+ *
+ * Use `@field()` when you need options beyond what plain TypeScript initializers
+ * express — required validation, numeric ranges, string length limits, uniqueness,
+ * or transient (non-persisted) computed properties.
+ *
+ * For plain persisted fields with no constraints, no decorator is needed: just
+ * declare the property with a TypeScript initializer and the framework will infer
+ * the column type from the default value (`0` → INTEGER, `0.0` → DECIMAL, `''` → TEXT).
+ *
+ * @param options - Field configuration options
+ * @param options.required - If `true`, `save()` throws `ValidationError` when empty/null
+ * @param options.unique - Enforces a UNIQUE database constraint
+ * @param options.nullable - If `true`, the column accepts NULL (default depends on type)
+ * @param options.transient - If `true`, the property is not persisted to the database
+ * @param options.default - Default value applied at the database level
+ * @param options.description - Human-readable description used in generated API docs
+ * @param options.exported - Controls JSON export visibility (see `FieldOptions`)
+ * @returns A TypeScript property decorator
+ *
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Product extends SmrtObject {
+ *   @field({ required: true, maxLength: 100 })
+ *   name: string = '';
+ *
+ *   @field({ min: 0 })
+ *   stock: number = 0;
+ *
+ *   @field({ transient: true })
+ *   get displayPrice(): string { return `$${this.price.toFixed(2)}`; }
+ * }
+ * ```
+ *
+ * @see {@link meta} for STI child-specific fields stored in `_meta_data` JSON
+ * @see {@link foreignKey} for typed relationship fields
+ */
+export declare function field(options?: FieldOptions | NumericFieldOptions | TextFieldOptions): CompatiblePropertyDecorator;
+/**
+ * Declares a many-to-one (foreign key) relationship to another `SmrtObject` class.
+ *
+ * The decorated property stores the UUID of the related object. At runtime, call
+ * `instance.loadRelated('fieldName')` to lazy-load (and cache) the related object,
+ * or pass `include: ['fieldName']` to `collection.list()` for batch eager loading.
+ *
+ * Cross-package rule: Use `@foreignKey()` only for same-package references.
+ * For cross-package foreign keys, use a plain `string` property instead to avoid
+ * circular dependencies between packages.
+ *
+ * @param relatedClass - The target class constructor (or class name string)
+ * @param options - Optional field constraints (required, nullable, etc.)
+ * @returns A TypeScript property decorator
+ *
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Order extends SmrtObject {
+ *   // Same-package FK — enables loadRelated() and eager loading
+ *   @foreignKey(Customer)
+ *   customerId: string = '';
+ * }
+ *
+ * // Cross-package: use a plain string instead
+ * @smrt()
+ * class Post extends SmrtObject {
+ *   authorId: string = ''; // plain string — no circular dep
+ * }
+ * ```
+ *
+ * @see {@link oneToMany} for the inverse (parent) side of the relationship
+ * @see SmrtObject.loadRelated for lazy-loading the related object at runtime
+ */
+export declare function foreignKey(relatedClass: string | Function | any, options?: Omit<RelationshipFieldOptions, 'related'>): CompatiblePropertyDecorator;
+/**
+ * Declares a cross-package foreign key reference.
+ *
+ * Use this for relationships that point to a `SmrtObject` in a *different* package
+ * (e.g. `Customer.profileId` pointing at `@happyvertical/smrt-profiles:Profile`).
+ * Unlike `@foreignKey()`, this decorator does **not** emit a DDL `FOREIGN KEY`
+ * constraint — cross-package classes are not visible at schema-generation time and
+ * adding a constraint would force a circular package dependency. The decorated
+ * property remains a plain `TEXT` column at the database level.
+ *
+ * What you get over a plain string field:
+ * - The relationship is registered with the `ObjectRegistry`, so `loadRelated()`
+ *   and `Collection.list({ include })` can resolve it once the target package's
+ *   manifest is loaded.
+ * - Optional save-time validation (`validate: true`) confirms the referenced
+ *   object exists, catching typos and stale IDs before they hit the database.
+ *
+ * The `qualifiedName` is a fully-qualified class identifier in the form
+ * `@package/scope:ClassName` — for example `@happyvertical/smrt-profiles:Profile`.
+ *
+ * @param qualifiedName - Qualified name of the target class
+ * @param options - Optional field constraints and `validate` flag
+ * @returns A TypeScript property decorator
+ *
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Customer extends SmrtObject {
+ *   @crossPackageRef('@happyvertical/smrt-profiles:Profile')
+ *   profileId: string = '';
+ *
+ *   // With save-time validation
+ *   @crossPackageRef('@happyvertical/smrt-profiles:Profile', { validate: true })
+ *   primaryContactId: string = '';
+ * }
+ * ```
+ *
+ * @see {@link foreignKey} for same-package relationships (emits FK constraint)
+ * @see SmrtObject.loadRelated for runtime resolution
+ */
+export declare function crossPackageRef(qualifiedName: string, options?: CrossPackageRefOptions): CompatiblePropertyDecorator;
+/**
+ * Declares a one-to-many relationship from this object to a collection of related objects.
+ *
+ * The decorated property is `transient` — it is not persisted as a database column.
+ * At runtime, call `instance.loadRelatedMany('fieldName')` to load the related objects,
+ * or pass `include: ['fieldName']` to `collection.list()` for batch eager loading (issues
+ * a single batched query for all instances instead of N individual queries).
+ *
+ * The inverse side (`@foreignKey`) must exist on the `relatedClass` pointing back to this
+ * class. The framework discovers it automatically via `ObjectRegistry.getInverseRelationships()`.
+ *
+ * **Generated accessor (R10):** registering the class installs a consistent
+ * `get<FieldName>()` instance method (e.g. `items` → `order.getItems()`) that
+ * delegates to `loadRelatedMany('items')`. Generation is additive — a
+ * hand-rolled method of the same name is never overwritten.
+ *
+ * **Disambiguation:** when `relatedClass` declares more than one `@foreignKey`
+ * back to this class, pass `{ foreignKey: '<inverseFieldName>' }` so both
+ * `loadRelatedMany` and the generated accessor resolve the intended inverse
+ * side. Without it the first matching foreign key is used.
+ *
+ * @param relatedClass - The class constructor of the child/related objects
+ * @param options - Optional relationship options. `foreignKey` selects the
+ *   inverse foreign-key field on `relatedClass` when it has more than one.
+ * @returns A TypeScript property decorator (sets `transient: true` automatically)
+ *
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Order extends SmrtObject {
+ *   @oneToMany(OrderItem)
+ *   items: OrderItem[] = [];
+ * }
+ *
+ * @smrt()
+ * class OrderItem extends SmrtObject {
+ *   @foreignKey(Order)
+ *   orderId: string = '';
+ * }
+ *
+ * const order = await orders.get({ id });
+ * const items = await order.getItems(); // generated; === loadRelatedMany('items')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple inverse foreign keys → disambiguate explicitly.
+ * @smrt()
+ * class Profile extends SmrtObject {
+ *   @oneToMany(ProfileRelationship, { foreignKey: 'fromProfileId' })
+ *   relationshipsFrom: ProfileRelationship[] = [];
+ *   @oneToMany(ProfileRelationship, { foreignKey: 'toProfileId' })
+ *   relationshipsTo: ProfileRelationship[] = [];
+ * }
+ * ```
+ *
+ * @see {@link foreignKey} for the many-to-one (child) side of the relationship
+ * @see SmrtObject.loadRelatedMany for lazy-loading at runtime
+ */
+export declare function oneToMany(relatedClass: string | Function | any, options?: Omit<RelationshipFieldOptions, 'related'>): CompatiblePropertyDecorator;
+/**
+ * Declares a many-to-many relationship between two `SmrtObject` classes via a join table.
+ *
+ * The decorated property is `transient` — it is not persisted as a database column.
+ * The `through` option specifies the junction table name. The join table model must
+ * be decorated with `@smrt({ conflictColumns: ['...', '...'] })` to use the natural
+ * key columns for upsert operations.
+ *
+ * Runtime loading: call `instance.loadRelatedMany('field')` to lazy-load, or
+ * pass `include: ['field']` to `collection.list()` for batched eager loading.
+ *
+ * @param relatedClass - The class constructor of the related objects
+ * @param options - Relationship options; `through` specifies the junction table name
+ * @returns A TypeScript property decorator (sets `transient: true` automatically)
+ *
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Product extends SmrtObject {
+ *   @manyToMany(Tag, { through: 'product_tags' })
+ *   tags: Tag[] = [];
+ * }
+ * ```
+ *
+ * @see {@link oneToMany} for one-to-many relationships
+ */
+export declare function manyToMany(relatedClass: string | Function | any, options?: Omit<RelationshipFieldOptions, 'related'>): CompatiblePropertyDecorator;
+/**
+ * Marks a field as a Single Table Inheritance (STI) meta field.
+ *
+ * Meta fields are stored in the `_meta_data` JSONB column on the shared STI
+ * table rather than as dedicated table columns. Use this decorator for fields
+ * that are specific to an STI child class and should not pollute the shared
+ * table schema with child-specific columns.
+ *
+ * The `@smrt({ tableStrategy: 'sti' })` decorator must be set on the base class.
+ * All child-specific fields should use `@meta()` (or the `Meta<T>` type alias).
+ *
+ * @param options - Standard field options (required, nullable, description, etc.)
+ * @returns A TypeScript property decorator (registers field with `type: 'meta'`)
+ *
+ * @example
+ * ```typescript
+ * @smrt({ tableStrategy: 'sti' })
+ * class Event extends SmrtObject {
+ *   title: string = ''; // shared column on events table
+ * }
+ *
+ * @smrt()
+ * class Meeting extends Event {
+ *   @meta()
+ *   roomNumber: string = ''; // stored in _meta_data JSON, not a column
+ *
+ *   @meta({ required: true })
+ *   durationMinutes: number = 60;
+ * }
+ * ```
+ *
+ * @see {@link Meta} for the equivalent type alias approach
+ * @see {@link field} for regular (non-STI) field declarations
+ */
+export declare function meta(options?: FieldOptions): CompatiblePropertyDecorator;
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"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"}

package/dist/decorators/index.js

@@ -0,0 +1,104 @@
+import { ObjectRegistry } from "../registry.js";
+import { registerCompatibleFieldDecorator } from "./compatibility.js";
+function field(options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, options);
+      }
+    );
+  });
+}
+function foreignKey(relatedClass, options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    const relatedClassName = typeof relatedClass === "string" ? relatedClass : relatedClass.name;
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, {
+          ...options,
+          type: "foreignKey",
+          related: relatedClassName
+        });
+      }
+    );
+  });
+}
+function crossPackageRef(qualifiedName, options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, {
+          ...options,
+          type: "crossPackageRef",
+          related: qualifiedName
+        });
+      }
+    );
+  });
+}
+function oneToMany(relatedClass, options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    const relatedClassName = typeof relatedClass === "string" ? relatedClass : relatedClass.name;
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, {
+          ...options,
+          type: "oneToMany",
+          related: relatedClassName,
+          transient: true
+          // Relationship fields are not database columns
+        });
+      }
+    );
+  });
+}
+function manyToMany(relatedClass, options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    const relatedClassName = typeof relatedClass === "string" ? relatedClass : relatedClass.name;
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, {
+          ...options,
+          type: "manyToMany",
+          related: relatedClassName,
+          transient: true
+          // Relationship fields are not database columns
+        });
+      }
+    );
+  });
+}
+function meta(options = {}) {
+  return ((targetOrValue, propertyKeyOrContext) => {
+    registerCompatibleFieldDecorator(
+      targetOrValue,
+      propertyKeyOrContext,
+      (className, propertyKey) => {
+        ObjectRegistry.registerFieldDecorator(className, propertyKey, {
+          ...options,
+          type: "meta"
+          // Mark this field as a meta field for STI
+        });
+      }
+    );
+  });
+}
+export {
+  crossPackageRef,
+  field,
+  foreignKey,
+  manyToMany,
+  meta,
+  oneToMany
+};
+//# sourceMappingURL=index.js.map