@happyvertical/smrt-core 0.40.70 → 0.41.0

package/dist/schema/conflict-target.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Conflict target (upsert natural key) resolution shared by every schema path
+ * and by the runtime (#2360, epic #2382 finding B1/A4).
+ *
+ * `SmrtObject.save()` upserts a NEW object on
+ * `ObjectRegistry.getConflictColumns()`; the schema generator emits ONE unique
+ * index over the same columns so `INSERT … ON CONFLICT (…)` binds on every
+ * engine. Before #2360 the tenancy interceptor populated `tenant_id` on save
+ * but neither the conflict target nor the unique index carried it, so a
+ * second tenant creating the same natural key (`slug`, `context`) matched the
+ * first tenant's row and `DO UPDATE SET` rewrote its `id` and `tenant_id`
+ * (probed: tenant A's row was silently adopted by tenant B).
+ *
+ * The rule now: **a tenant-scoped class's default conflict target is
+ * `[tenantColumn, ...naturalKey]`** on the build path (manifest
+ * `decoratorConfig.conflictColumns`, materialized by
+ * `ManifestGenerator.normalizeConflictColumns()`) and on the runtime path
+ * (`ObjectRegistry.getConflictColumns()`), so schema and upsert agree by
+ * construction. Explicit `@smrt({ conflictColumns })` always wins and is
+ * never rewritten — a class that declares its own natural key owns it.
+ *
+ * NULL-tenant rows (`mode: 'optional'` outside a tenant context) keep the
+ * SDK's null-aware upsert semantics: `@happyvertical/sql` matches conflict
+ * columns with `IS NOT DISTINCT FROM`, so `(NULL, 'widget', '')` updates the
+ * existing `(NULL, 'widget', '')` row through the model layer even though the
+ * database index treats NULLs as distinct. Global rows therefore dedup among
+ * themselves exactly as every row did before, and per-tenant rows dedup per
+ * tenant.
+ *
+ * Index NAMES stay stable across this change — the tenant-led default key
+ * keeps `<table>_slug_context_idx` (CTI) / `<table>_slug_context_meta_type_idx`
+ * (STI) — so `SchemaComparer`'s same-name shape-drift repair swaps the columns
+ * in place (`DROP INDEX` + `CREATE UNIQUE INDEX`) instead of leaving the old
+ * global unique index behind to keep blocking cross-tenant duplicates. The new
+ * key is a superset of the old one, so creating it cannot fail on existing
+ * data.
+ */
+/** Default natural key of a class-per-table (CTI) object. */
+export declare const DEFAULT_CTI_CONFLICT_COLUMNS: readonly string[];
+/**
+ * Default natural key of a single-table-inheritance (STI) hierarchy: the
+ * discriminator participates in identity so two subtypes may share a slug.
+ */
+export declare const DEFAULT_STI_CONFLICT_COLUMNS: readonly string[];
+export type ConflictTableStrategy = 'cti' | 'sti';
+/**
+ * The default conflict target for a table with the given strategy, led by the
+ * tenant column when the schema-owning class is tenant-scoped.
+ */
+export declare function defaultConflictColumns(strategy: ConflictTableStrategy, tenantColumn?: string | null): string[];
+/**
+ * Resolve the conflict target of a table.
+ *
+ * `explicit` (a declared `@smrt({ conflictColumns })`) always wins; otherwise
+ * the strategy default, tenant-led when `tenantColumn` is given.
+ */
+export declare function resolveConflictColumns(options: {
+    explicit?: readonly string[] | null;
+    strategy: ConflictTableStrategy;
+    tenantColumn?: string | null;
+}): string[];
+/**
+ * Whether `conflictColumns` is exactly a default natural key (CTI or STI),
+ * optionally led by `tenantColumn`. Used to keep the default index names
+ * stable when the tenant column is prepended.
+ */
+export declare function isDefaultNaturalKey(conflictColumns: readonly string[], tenantColumn?: string | null): boolean;
+/**
+ * The stable name of the unique conflict index for `conflictColumns`.
+ *
+ * - default CTI key `(slug, context)` → `<table>_slug_context_idx`
+ * - default STI key `(slug, context, _meta_type)` →
+ *   `<table>_slug_context_meta_type_idx`
+ * - either default led by the tenant column → the SAME name as without it
+ *   (#2360: the differ swaps the columns in place by name)
+ * - any custom key → `<table>_<first two columns>_idx` (the historical rule;
+ *   a longer key keeps the two-column name so existing databases are not
+ *   renamed)
+ *
+ * @param tenantColumn - the table's tenant column, when the schema owner is
+ *   tenant-scoped; only consulted to recognize a tenant-led default key
+ */
+export declare function conflictIndexName(tableName: string, conflictColumns: readonly string[], tenantColumn?: string | null): string;
+/**
+ * Whether an unqualified index over `indexColumns` serves slug lookups
+ * (`loadFromSlug()` / `getId()` / `getSavedId()` filter on `slug`, `context`):
+ * it leads with `slug`, or it is the tenant-led default key — a tenant-scoped
+ * lookup carries the tenant predicate (#2365) and is served by the prefix.
+ */
+export declare function servesSlugLookup(indexColumns: readonly string[], tenantColumn?: string | null): boolean;
+/**
+ * The tenant column of a table, from the schema-owning class's normalized
+ * tenant-scoped configuration. Returns `undefined` when the class is not
+ * tenant-scoped or the configured field is not among its fields (the field is
+ * always injected for tenant-scoped classes; the guard keeps the runtime and
+ * build paths honest about the column actually existing).
+ *
+ * @param tenantField - the configured tenant field name (`tenantScoped.field`,
+ *   default `tenantId`), or `undefined` when the class is not tenant-scoped
+ * @param hasField - whether the schema owner declares that field
+ * @param toColumn - field-name → column-name conversion (`toSnakeCase`)
+ */
+export declare function resolveTenantColumn(tenantField: string | undefined | null, hasField: (fieldName: string) => boolean, toColumn: (fieldName: string) => string): string | undefined;
+//# sourceMappingURL=conflict-target.d.ts.map

package/dist/schema/conflict-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-target.d.ts","sourceRoot":"","sources":["../../src/schema/conflict-target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAGzD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAIzD,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,KAAK,GAAG,KAAK,CAAC;AAElD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,qBAAqB,EAC/B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,EAAE,CAMV;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,GAAG,MAAM,EAAE,CAKX;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAST;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,CAYR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAQT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACtC,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,EACxC,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GACtC,MAAM,GAAG,SAAS,CAGpB"}

package/dist/schema/conflict-target.js

@@ -0,0 +1,129 @@
+//#region src/schema/conflict-target.ts
+/**
+* Conflict target (upsert natural key) resolution shared by every schema path
+* and by the runtime (#2360, epic #2382 finding B1/A4).
+*
+* `SmrtObject.save()` upserts a NEW object on
+* `ObjectRegistry.getConflictColumns()`; the schema generator emits ONE unique
+* index over the same columns so `INSERT … ON CONFLICT (…)` binds on every
+* engine. Before #2360 the tenancy interceptor populated `tenant_id` on save
+* but neither the conflict target nor the unique index carried it, so a
+* second tenant creating the same natural key (`slug`, `context`) matched the
+* first tenant's row and `DO UPDATE SET` rewrote its `id` and `tenant_id`
+* (probed: tenant A's row was silently adopted by tenant B).
+*
+* The rule now: **a tenant-scoped class's default conflict target is
+* `[tenantColumn, ...naturalKey]`** on the build path (manifest
+* `decoratorConfig.conflictColumns`, materialized by
+* `ManifestGenerator.normalizeConflictColumns()`) and on the runtime path
+* (`ObjectRegistry.getConflictColumns()`), so schema and upsert agree by
+* construction. Explicit `@smrt({ conflictColumns })` always wins and is
+* never rewritten — a class that declares its own natural key owns it.
+*
+* NULL-tenant rows (`mode: 'optional'` outside a tenant context) keep the
+* SDK's null-aware upsert semantics: `@happyvertical/sql` matches conflict
+* columns with `IS NOT DISTINCT FROM`, so `(NULL, 'widget', '')` updates the
+* existing `(NULL, 'widget', '')` row through the model layer even though the
+* database index treats NULLs as distinct. Global rows therefore dedup among
+* themselves exactly as every row did before, and per-tenant rows dedup per
+* tenant.
+*
+* Index NAMES stay stable across this change — the tenant-led default key
+* keeps `<table>_slug_context_idx` (CTI) / `<table>_slug_context_meta_type_idx`
+* (STI) — so `SchemaComparer`'s same-name shape-drift repair swaps the columns
+* in place (`DROP INDEX` + `CREATE UNIQUE INDEX`) instead of leaving the old
+* global unique index behind to keep blocking cross-tenant duplicates. The new
+* key is a superset of the old one, so creating it cannot fail on existing
+* data.
+*/
+/** Default natural key of a class-per-table (CTI) object. */
+var DEFAULT_CTI_CONFLICT_COLUMNS = ["slug", "context"];
+/**
+* Default natural key of a single-table-inheritance (STI) hierarchy: the
+* discriminator participates in identity so two subtypes may share a slug.
+*/
+var DEFAULT_STI_CONFLICT_COLUMNS = [
+	"slug",
+	"context",
+	"_meta_type"
+];
+/**
+* The default conflict target for a table with the given strategy, led by the
+* tenant column when the schema-owning class is tenant-scoped.
+*/
+function defaultConflictColumns(strategy, tenantColumn) {
+	const naturalKey = strategy === "sti" ? [...DEFAULT_STI_CONFLICT_COLUMNS] : [...DEFAULT_CTI_CONFLICT_COLUMNS];
+	return tenantColumn ? [tenantColumn, ...naturalKey] : naturalKey;
+}
+/**
+* Resolve the conflict target of a table.
+*
+* `explicit` (a declared `@smrt({ conflictColumns })`) always wins; otherwise
+* the strategy default, tenant-led when `tenantColumn` is given.
+*/
+function resolveConflictColumns(options) {
+	if (options.explicit && options.explicit.length > 0) return [...options.explicit];
+	return defaultConflictColumns(options.strategy, options.tenantColumn);
+}
+function sameColumns(a, b) {
+	return a.length === b.length && a.every((column, i) => column === b[i]);
+}
+/**
+* Whether `conflictColumns` is exactly a default natural key (CTI or STI),
+* optionally led by `tenantColumn`. Used to keep the default index names
+* stable when the tenant column is prepended.
+*/
+function isDefaultNaturalKey(conflictColumns, tenantColumn) {
+	const key = tenantColumn && conflictColumns[0] === tenantColumn ? conflictColumns.slice(1) : conflictColumns;
+	return sameColumns(key, DEFAULT_CTI_CONFLICT_COLUMNS) || sameColumns(key, DEFAULT_STI_CONFLICT_COLUMNS);
+}
+/**
+* The stable name of the unique conflict index for `conflictColumns`.
+*
+* - default CTI key `(slug, context)` → `<table>_slug_context_idx`
+* - default STI key `(slug, context, _meta_type)` →
+*   `<table>_slug_context_meta_type_idx`
+* - either default led by the tenant column → the SAME name as without it
+*   (#2360: the differ swaps the columns in place by name)
+* - any custom key → `<table>_<first two columns>_idx` (the historical rule;
+*   a longer key keeps the two-column name so existing databases are not
+*   renamed)
+*
+* @param tenantColumn - the table's tenant column, when the schema owner is
+*   tenant-scoped; only consulted to recognize a tenant-led default key
+*/
+function conflictIndexName(tableName, conflictColumns, tenantColumn) {
+	const key = tenantColumn && conflictColumns[0] === tenantColumn && isDefaultNaturalKey(conflictColumns, tenantColumn) ? conflictColumns.slice(1) : conflictColumns;
+	if (sameColumns(key, DEFAULT_STI_CONFLICT_COLUMNS)) return `${tableName}_slug_context_meta_type_idx`;
+	return `${tableName}_${(key.length > 2 ? key.slice(0, 2) : key).join("_")}_idx`;
+}
+/**
+* Whether an unqualified index over `indexColumns` serves slug lookups
+* (`loadFromSlug()` / `getId()` / `getSavedId()` filter on `slug`, `context`):
+* it leads with `slug`, or it is the tenant-led default key — a tenant-scoped
+* lookup carries the tenant predicate (#2365) and is served by the prefix.
+*/
+function servesSlugLookup(indexColumns, tenantColumn) {
+	if (indexColumns[0] === "slug") return true;
+	return Boolean(tenantColumn && indexColumns[0] === tenantColumn && indexColumns[1] === "slug" && indexColumns[2] === "context");
+}
+/**
+* The tenant column of a table, from the schema-owning class's normalized
+* tenant-scoped configuration. Returns `undefined` when the class is not
+* tenant-scoped or the configured field is not among its fields (the field is
+* always injected for tenant-scoped classes; the guard keeps the runtime and
+* build paths honest about the column actually existing).
+*
+* @param tenantField - the configured tenant field name (`tenantScoped.field`,
+*   default `tenantId`), or `undefined` when the class is not tenant-scoped
+* @param hasField - whether the schema owner declares that field
+* @param toColumn - field-name → column-name conversion (`toSnakeCase`)
+*/
+function resolveTenantColumn(tenantField, hasField, toColumn) {
+	if (!tenantField || !hasField(tenantField)) return void 0;
+	return toColumn(tenantField);
+}
+//#endregion
+export { DEFAULT_CTI_CONFLICT_COLUMNS, DEFAULT_STI_CONFLICT_COLUMNS, conflictIndexName, defaultConflictColumns, isDefaultNaturalKey, resolveConflictColumns, resolveTenantColumn, servesSlugLookup };
+
+//# sourceMappingURL=conflict-target.js.map

package/dist/schema/conflict-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-target.js","names":[],"sources":["../../src/schema/conflict-target.ts"],"sourcesContent":["/**\n * Conflict target (upsert natural key) resolution shared by every schema path\n * and by the runtime (#2360, epic #2382 finding B1/A4).\n *\n * `SmrtObject.save()` upserts a NEW object on\n * `ObjectRegistry.getConflictColumns()`; the schema generator emits ONE unique\n * index over the same columns so `INSERT … ON CONFLICT (…)` binds on every\n * engine. Before #2360 the tenancy interceptor populated `tenant_id` on save\n * but neither the conflict target nor the unique index carried it, so a\n * second tenant creating the same natural key (`slug`, `context`) matched the\n * first tenant's row and `DO UPDATE SET` rewrote its `id` and `tenant_id`\n * (probed: tenant A's row was silently adopted by tenant B).\n *\n * The rule now: **a tenant-scoped class's default conflict target is\n * `[tenantColumn, ...naturalKey]`** on the build path (manifest\n * `decoratorConfig.conflictColumns`, materialized by\n * `ManifestGenerator.normalizeConflictColumns()`) and on the runtime path\n * (`ObjectRegistry.getConflictColumns()`), so schema and upsert agree by\n * construction. Explicit `@smrt({ conflictColumns })` always wins and is\n * never rewritten — a class that declares its own natural key owns it.\n *\n * NULL-tenant rows (`mode: 'optional'` outside a tenant context) keep the\n * SDK's null-aware upsert semantics: `@happyvertical/sql` matches conflict\n * columns with `IS NOT DISTINCT FROM`, so `(NULL, 'widget', '')` updates the\n * existing `(NULL, 'widget', '')` row through the model layer even though the\n * database index treats NULLs as distinct. Global rows therefore dedup among\n * themselves exactly as every row did before, and per-tenant rows dedup per\n * tenant.\n *\n * Index NAMES stay stable across this change — the tenant-led default key\n * keeps `<table>_slug_context_idx` (CTI) / `<table>_slug_context_meta_type_idx`\n * (STI) — so `SchemaComparer`'s same-name shape-drift repair swaps the columns\n * in place (`DROP INDEX` + `CREATE UNIQUE INDEX`) instead of leaving the old\n * global unique index behind to keep blocking cross-tenant duplicates. The new\n * key is a superset of the old one, so creating it cannot fail on existing\n * data.\n */\n\n/** Default natural key of a class-per-table (CTI) object. */\nexport const DEFAULT_CTI_CONFLICT_COLUMNS: readonly string[] = [\n  'slug',\n  'context',\n];\n\n/**\n * Default natural key of a single-table-inheritance (STI) hierarchy: the\n * discriminator participates in identity so two subtypes may share a slug.\n */\nexport const DEFAULT_STI_CONFLICT_COLUMNS: readonly string[] = [\n  'slug',\n  'context',\n  '_meta_type',\n];\n\nexport type ConflictTableStrategy = 'cti' | 'sti';\n\n/**\n * The default conflict target for a table with the given strategy, led by the\n * tenant column when the schema-owning class is tenant-scoped.\n */\nexport function defaultConflictColumns(\n  strategy: ConflictTableStrategy,\n  tenantColumn?: string | null,\n): string[] {\n  const naturalKey =\n    strategy === 'sti'\n      ? [...DEFAULT_STI_CONFLICT_COLUMNS]\n      : [...DEFAULT_CTI_CONFLICT_COLUMNS];\n  return tenantColumn ? [tenantColumn, ...naturalKey] : naturalKey;\n}\n\n/**\n * Resolve the conflict target of a table.\n *\n * `explicit` (a declared `@smrt({ conflictColumns })`) always wins; otherwise\n * the strategy default, tenant-led when `tenantColumn` is given.\n */\nexport function resolveConflictColumns(options: {\n  explicit?: readonly string[] | null;\n  strategy: ConflictTableStrategy;\n  tenantColumn?: string | null;\n}): string[] {\n  if (options.explicit && options.explicit.length > 0) {\n    return [...options.explicit];\n  }\n  return defaultConflictColumns(options.strategy, options.tenantColumn);\n}\n\nfunction sameColumns(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((column, i) => column === b[i]);\n}\n\n/**\n * Whether `conflictColumns` is exactly a default natural key (CTI or STI),\n * optionally led by `tenantColumn`. Used to keep the default index names\n * stable when the tenant column is prepended.\n */\nexport function isDefaultNaturalKey(\n  conflictColumns: readonly string[],\n  tenantColumn?: string | null,\n): boolean {\n  const key =\n    tenantColumn && conflictColumns[0] === tenantColumn\n      ? conflictColumns.slice(1)\n      : conflictColumns;\n  return (\n    sameColumns(key, DEFAULT_CTI_CONFLICT_COLUMNS) ||\n    sameColumns(key, DEFAULT_STI_CONFLICT_COLUMNS)\n  );\n}\n\n/**\n * The stable name of the unique conflict index for `conflictColumns`.\n *\n * - default CTI key `(slug, context)` → `<table>_slug_context_idx`\n * - default STI key `(slug, context, _meta_type)` →\n *   `<table>_slug_context_meta_type_idx`\n * - either default led by the tenant column → the SAME name as without it\n *   (#2360: the differ swaps the columns in place by name)\n * - any custom key → `<table>_<first two columns>_idx` (the historical rule;\n *   a longer key keeps the two-column name so existing databases are not\n *   renamed)\n *\n * @param tenantColumn - the table's tenant column, when the schema owner is\n *   tenant-scoped; only consulted to recognize a tenant-led default key\n */\nexport function conflictIndexName(\n  tableName: string,\n  conflictColumns: readonly string[],\n  tenantColumn?: string | null,\n): string {\n  const key =\n    tenantColumn &&\n    conflictColumns[0] === tenantColumn &&\n    isDefaultNaturalKey(conflictColumns, tenantColumn)\n      ? conflictColumns.slice(1)\n      : conflictColumns;\n  if (sameColumns(key, DEFAULT_STI_CONFLICT_COLUMNS)) {\n    return `${tableName}_slug_context_meta_type_idx`;\n  }\n  const nameColumns = key.length > 2 ? key.slice(0, 2) : key;\n  return `${tableName}_${nameColumns.join('_')}_idx`;\n}\n\n/**\n * Whether an unqualified index over `indexColumns` serves slug lookups\n * (`loadFromSlug()` / `getId()` / `getSavedId()` filter on `slug`, `context`):\n * it leads with `slug`, or it is the tenant-led default key — a tenant-scoped\n * lookup carries the tenant predicate (#2365) and is served by the prefix.\n */\nexport function servesSlugLookup(\n  indexColumns: readonly string[],\n  tenantColumn?: string | null,\n): boolean {\n  if (indexColumns[0] === 'slug') return true;\n  return Boolean(\n    tenantColumn &&\n      indexColumns[0] === tenantColumn &&\n      indexColumns[1] === 'slug' &&\n      indexColumns[2] === 'context',\n  );\n}\n\n/**\n * The tenant column of a table, from the schema-owning class's normalized\n * tenant-scoped configuration. Returns `undefined` when the class is not\n * tenant-scoped or the configured field is not among its fields (the field is\n * always injected for tenant-scoped classes; the guard keeps the runtime and\n * build paths honest about the column actually existing).\n *\n * @param tenantField - the configured tenant field name (`tenantScoped.field`,\n *   default `tenantId`), or `undefined` when the class is not tenant-scoped\n * @param hasField - whether the schema owner declares that field\n * @param toColumn - field-name → column-name conversion (`toSnakeCase`)\n */\nexport function resolveTenantColumn(\n  tenantField: string | undefined | null,\n  hasField: (fieldName: string) => boolean,\n  toColumn: (fieldName: string) => string,\n): string | undefined {\n  if (!tenantField || !hasField(tenantField)) return undefined;\n  return toColumn(tenantField);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,+BAAkD,CAC7D,QACA,SACF;;;;;AAMA,IAAa,+BAAkD;CAC7D;CACA;CACA;AACF;;;;;AAQA,SAAgB,uBACd,UACA,cACU;CACV,MAAM,aACJ,aAAa,QACT,CAAC,GAAG,4BAA4B,IAChC,CAAC,GAAG,4BAA4B;CACtC,OAAO,eAAe,CAAC,cAAc,GAAG,UAAU,IAAI;AACxD;;;;;;;AAQA,SAAgB,uBAAuB,SAI1B;CACX,IAAI,QAAQ,YAAY,QAAQ,SAAS,SAAS,GAChD,OAAO,CAAC,GAAG,QAAQ,QAAQ;CAE7B,OAAO,uBAAuB,QAAQ,UAAU,QAAQ,YAAY;AACtE;AAEA,SAAS,YAAY,GAAsB,GAA+B;CACxE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,QAAQ,MAAM,WAAW,EAAE,EAAE;AACxE;;;;;;AAOA,SAAgB,oBACd,iBACA,cACS;CACT,MAAM,MACJ,gBAAgB,gBAAgB,OAAO,eACnC,gBAAgB,MAAM,CAAC,IACvB;CACN,OACE,YAAY,KAAK,4BAA4B,KAC7C,YAAY,KAAK,4BAA4B;AAEjD;;;;;;;;;;;;;;;;AAiBA,SAAgB,kBACd,WACA,iBACA,cACQ;CACR,MAAM,MACJ,gBACA,gBAAgB,OAAO,gBACvB,oBAAoB,iBAAiB,YAAY,IAC7C,gBAAgB,MAAM,CAAC,IACvB;CACN,IAAI,YAAY,KAAK,4BAA4B,GAC/C,OAAO,GAAG,UAAU;CAGtB,OAAO,GAAG,UAAU,IADA,IAAI,SAAS,IAAI,IAAI,MAAM,GAAG,CAAC,IAAI,IAAA,CACpB,KAAK,GAAG,EAAE;AAC/C;;;;;;;AAQA,SAAgB,iBACd,cACA,cACS;CACT,IAAI,aAAa,OAAO,QAAQ,OAAO;CACvC,OAAO,QACL,gBACE,aAAa,OAAO,gBACpB,aAAa,OAAO,UACpB,aAAa,OAAO,SACxB;AACF;;;;;;;;;;;;;AAcA,SAAgB,oBACd,aACA,UACA,UACoB;CACpB,IAAI,CAAC,eAAe,CAAC,SAAS,WAAW,GAAG,OAAO,KAAA;CACnD,OAAO,SAAS,WAAW;AAC7B"}

package/dist/schema/ddl/duckdb-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duckdb-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAY;IAE3C;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAalC;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE;IA4BnD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAIrD;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;;;OAKG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}
+{"version":3,"file":"duckdb-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAY;IAE3C;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAalC;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAwCnD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAIrD;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;;;OAKG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

package/dist/schema/ddl/duckdb-strategy.js

@@ -1,5 +1,5 @@
 import { BaseDDLStrategy } from "./base-strategy.js";
-import { renderIndexTarget } from "../index-utils.js";
+import { isStiSubtypeUniqueIndex, renderIndexTarget } from "../index-utils.js";
 //#region src/schema/ddl/duckdb-strategy.ts
 /**
 * DuckDB DDL Strategy
@@ -37,6 +37,7 @@ var DuckDBStrategy = class extends BaseDDLStrategy {
 		const statements = [];
 		for (const index of indexes) {
 			if (index.unique && !index.where && !index.jsonPath) continue;
+			if (isStiSubtypeUniqueIndex(index)) continue;
 			const target = renderIndexTarget(index, this.engine);
 			if (!target) continue;
 			let sql = `CREATE ${index.unique ? "UNIQUE INDEX" : "INDEX"} IF NOT EXISTS "${index.name}" ON "${tableName}" (${target})`;

package/dist/schema/ddl/duckdb-strategy.js.map

@@ -1 +1 @@
-{"version":3,"file":"duckdb-strategy.js","names":[],"sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"sourcesContent":["/**\n * DuckDB DDL Strategy\n *\n * DuckDB-specific DDL generation with the following characteristics:\n * - UNIQUE constraints MUST be inline for UPSERT to work (DuckDB issue #12684)\n * - Supports CAST in DEFAULT values\n * - Native BOOLEAN, JSON types\n * - Does NOT support triggers\n *\n * CRITICAL: DuckDB's ON CONFLICT clause only works with inline UNIQUE constraints,\n * not with separate UNIQUE indexes. This is a known DuckDB limitation.\n */\n\nimport { renderIndexTarget } from '../index-utils.js';\nimport type { SchemaDefinition, SQLDataType } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class DuckDBStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'duckdb';\n\n  /**\n   * Map types for DuckDB\n   * DuckDB has native support for most types\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'TIMESTAMP':\n        return 'TIMESTAMP'; // DuckDB supports TIMESTAMP natively\n      case 'JSON':\n        return 'JSON'; // DuckDB has native JSON type\n      case 'UUID':\n        return 'UUID'; // DuckDB has a native UUID type (R11)\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate CREATE INDEX statements\n   *\n   * CRITICAL: Skip UNIQUE indexes - they must be inline constraints for UPSERT\n   */\n  generateIndexes(schema: SchemaDefinition): string[] {\n    const { tableName, indexes } = schema;\n    const statements: string[] = [];\n\n    for (const index of indexes) {\n      // Skip UNIQUE indexes - they're inline constraints\n      if (index.unique && !index.where && !index.jsonPath) {\n        continue;\n      }\n\n      const target = renderIndexTarget(index, this.engine);\n      if (!target) {\n        continue;\n      }\n      const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';\n      let sql = `CREATE ${indexType} IF NOT EXISTS \"${index.name}\" ON \"${tableName}\" (${target})`;\n\n      // DuckDB (and the JSON adapter backed by it) rejects partial indexes.\n      // Match the migration differ's documented compatibility behavior by\n      // degrading the declaration to a full index while preserving UNIQUE.\n\n      sql += ';';\n      statements.push(sql);\n    }\n\n    return statements;\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  generateTriggers(_schema: SchemaDefinition): string[] {\n    return []; // DuckDB doesn't support triggers\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  supportsTriggers(): boolean {\n    return false;\n  }\n\n  /**\n   * CRITICAL: DuckDB requires inline UNIQUE for UPSERT\n   *\n   * DuckDB issue #12684: ON CONFLICT only works with inline UNIQUE constraints,\n   * not with separate CREATE UNIQUE INDEX statements.\n   */\n  requiresInlineUnique(): boolean {\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,SAAkC;;;;;CAMlC,QAAQ,MAA2B;EACjC,QAAQ,MAAR;GACE,KAAK,aACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,SACE,OAAO,MAAM,QAAQ,IAAI;EAC7B;CACF;;;;;;CAOA,gBAAgB,QAAoC;EAClD,MAAM,EAAE,WAAW,YAAY;EAC/B,MAAM,aAAuB,CAAC;EAE9B,KAAK,MAAM,SAAS,SAAS;GAE3B,IAAI,MAAM,UAAU,CAAC,MAAM,SAAS,CAAC,MAAM,UACzC;GAGF,MAAM,SAAS,kBAAkB,OAAO,KAAK,MAAM;GACnD,IAAI,CAAC,QACH;GAGF,IAAI,MAAM,UADQ,MAAM,SAAS,iBAAiB,QACpB,kBAAkB,MAAM,KAAK,QAAQ,UAAU,KAAK,OAAO;GAMzF,OAAO;GACP,WAAW,KAAK,GAAG;EACrB;EAEA,OAAO;CACT;;;;CAKA,iBAAiB,SAAqC;EACpD,OAAO,CAAC;CACV;;;;CAKA,mBAA4B;EAC1B,OAAO;CACT;;;;;;;CAQA,uBAAgC;EAC9B,OAAO;CACT;AACF"}
+{"version":3,"file":"duckdb-strategy.js","names":[],"sources":["../../../src/schema/ddl/duckdb-strategy.ts"],"sourcesContent":["/**\n * DuckDB DDL Strategy\n *\n * DuckDB-specific DDL generation with the following characteristics:\n * - UNIQUE constraints MUST be inline for UPSERT to work (DuckDB issue #12684)\n * - Supports CAST in DEFAULT values\n * - Native BOOLEAN, JSON types\n * - Does NOT support triggers\n *\n * CRITICAL: DuckDB's ON CONFLICT clause only works with inline UNIQUE constraints,\n * not with separate UNIQUE indexes. This is a known DuckDB limitation.\n */\n\nimport { isStiSubtypeUniqueIndex, renderIndexTarget } from '../index-utils.js';\nimport type { SchemaDefinition, SQLDataType } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class DuckDBStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'duckdb';\n\n  /**\n   * Map types for DuckDB\n   * DuckDB has native support for most types\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'TIMESTAMP':\n        return 'TIMESTAMP'; // DuckDB supports TIMESTAMP natively\n      case 'JSON':\n        return 'JSON'; // DuckDB has native JSON type\n      case 'UUID':\n        return 'UUID'; // DuckDB has a native UUID type (R11)\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate CREATE INDEX statements\n   *\n   * CRITICAL: Skip UNIQUE indexes - they must be inline constraints for UPSERT\n   */\n  generateIndexes(schema: SchemaDefinition): string[] {\n    const { tableName, indexes } = schema;\n    const statements: string[] = [];\n\n    for (const index of indexes) {\n      // Skip UNIQUE indexes - they're inline constraints\n      if (index.unique && !index.where && !index.jsonPath) {\n        continue;\n      }\n\n      // An STI subtype-scoped UNIQUE (`unique: true` declared only on a\n      // descendant, #2359) cannot degrade to a full index the way the other\n      // partial indexes below do: dropping the predicate while keeping UNIQUE\n      // would enforce one subtype's constraint across every sibling's rows in\n      // the shared table. DuckDB has no faithful shape for it, so it is not\n      // emitted here (nor by the migration differ on this engine) — the\n      // constraint is simply not enforced on DuckDB/JSON. Caller-declared\n      // partial uniques (`WHERE active = TRUE`) keep degrading to full UNIQUE.\n      if (isStiSubtypeUniqueIndex(index)) {\n        continue;\n      }\n\n      const target = renderIndexTarget(index, this.engine);\n      if (!target) {\n        continue;\n      }\n      const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';\n      let sql = `CREATE ${indexType} IF NOT EXISTS \"${index.name}\" ON \"${tableName}\" (${target})`;\n\n      // DuckDB (and the JSON adapter backed by it) rejects partial indexes.\n      // Match the migration differ's documented compatibility behavior by\n      // degrading the declaration to a full index while preserving UNIQUE.\n\n      sql += ';';\n      statements.push(sql);\n    }\n\n    return statements;\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  generateTriggers(_schema: SchemaDefinition): string[] {\n    return []; // DuckDB doesn't support triggers\n  }\n\n  /**\n   * DuckDB does NOT support triggers\n   */\n  supportsTriggers(): boolean {\n    return false;\n  }\n\n  /**\n   * CRITICAL: DuckDB requires inline UNIQUE for UPSERT\n   *\n   * DuckDB issue #12684: ON CONFLICT only works with inline UNIQUE constraints,\n   * not with separate CREATE UNIQUE INDEX statements.\n   */\n  requiresInlineUnique(): boolean {\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,SAAkC;;;;;CAMlC,QAAQ,MAA2B;EACjC,QAAQ,MAAR;GACE,KAAK,aACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,SACE,OAAO,MAAM,QAAQ,IAAI;EAC7B;CACF;;;;;;CAOA,gBAAgB,QAAoC;EAClD,MAAM,EAAE,WAAW,YAAY;EAC/B,MAAM,aAAuB,CAAC;EAE9B,KAAK,MAAM,SAAS,SAAS;GAE3B,IAAI,MAAM,UAAU,CAAC,MAAM,SAAS,CAAC,MAAM,UACzC;GAWF,IAAI,wBAAwB,KAAK,GAC/B;GAGF,MAAM,SAAS,kBAAkB,OAAO,KAAK,MAAM;GACnD,IAAI,CAAC,QACH;GAGF,IAAI,MAAM,UADQ,MAAM,SAAS,iBAAiB,QACpB,kBAAkB,MAAM,KAAK,QAAQ,UAAU,KAAK,OAAO;GAMzF,OAAO;GACP,WAAW,KAAK,GAAG;EACrB;EAEA,OAAO;CACT;;;;CAKA,iBAAiB,SAAqC;EACpD,OAAO,CAAC;CACV;;;;CAKA,mBAA4B;EAC1B,OAAO;CACT;;;;;;;CAQA,uBAAgC;EAC9B,OAAO;CACT;AACF"}

package/dist/schema/ddl/postgres-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/postgres-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAc;IAE7C;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAkBlC;;;;;OAKG;IACH,SAAS,CAAC,wBAAwB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,iBAAiB,GACzB,MAAM;IAkDT;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;OAGG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}
+{"version":3,"file":"postgres-strategy.d.ts","sourceRoot":"","sources":["../../../src/schema/ddl/postgres-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAc;IAE7C;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAkBlC;;;;;OAKG;IACH,SAAS,CAAC,wBAAwB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,iBAAiB,GACzB,MAAM;IAsDT;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;OAGG;IACH,oBAAoB,IAAI,OAAO;CAGhC"}

package/dist/schema/ddl/postgres-strategy.js

@@ -1,5 +1,16 @@
 import { BaseDDLStrategy } from "./base-strategy.js";
+import { shortenIdentifier } from "../index-utils.js";
 //#region src/schema/ddl/postgres-strategy.ts
+/**
+* PostgreSQL DDL Strategy
+*
+* PostgreSQL-specific DDL generation with the following characteristics:
+* - JSONB type for JSON columns (more efficient than JSON)
+* - Native BOOLEAN type
+* - Full trigger support with PL/pgSQL functions
+* - UNIQUE can be inline or separate indexes
+* - Supports CAST in DEFAULT values
+*/
 var PostgresStrategy = class extends BaseDDLStrategy {
 	engine = "postgres";
 	/**
@@ -24,7 +35,7 @@ var PostgresStrategy = class extends BaseDDLStrategy {
 	*/
 	generateTriggerStatement(tableName, trigger) {
 		if (trigger.name.includes("updated_at")) {
-			const functionName = `update_${tableName}_updated_at`;
+			const functionName = shortenIdentifier(`update_${tableName}_updated_at`);
 			let sql = `-- Function for ${trigger.name}\n`;
 			sql += `CREATE OR REPLACE FUNCTION ${functionName}()\n`;
 			sql += `RETURNS TRIGGER AS $$\n`;

package/dist/schema/ddl/postgres-strategy.js.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-strategy.js","names":[],"sources":["../../../src/schema/ddl/postgres-strategy.ts"],"sourcesContent":["/**\n * PostgreSQL DDL Strategy\n *\n * PostgreSQL-specific DDL generation with the following characteristics:\n * - JSONB type for JSON columns (more efficient than JSON)\n * - Native BOOLEAN type\n * - Full trigger support with PL/pgSQL functions\n * - UNIQUE can be inline or separate indexes\n * - Supports CAST in DEFAULT values\n */\n\nimport type { SQLDataType, TriggerDefinition } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class PostgresStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'postgres';\n\n  /**\n   * Map types for PostgreSQL\n   * - JSON → JSONB (more efficient, supports indexing)\n   * - TIMESTAMP → TIMESTAMP WITH TIME ZONE (best practice)\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'JSON':\n        return 'JSONB'; // PostgreSQL JSONB is more efficient\n      case 'TIMESTAMP':\n        // JavaScript Date represents an instant. Preserve that contract in\n        // PostgreSQL instead of discarding the ISO offset in a timezone-naive\n        // TIMESTAMP column and reinterpreting the wall time at hydration.\n        return 'TIMESTAMPTZ';\n      case 'REAL':\n        return 'DOUBLE PRECISION'; // PostgreSQL convention\n      case 'UUID':\n        return 'uuid'; // Native 16-byte uuid (R11) — vs 37-byte text\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate trigger for PostgreSQL\n   *\n   * PostgreSQL triggers require a separate function, then the trigger.\n   * For updated_at timestamps, we generate both.\n   */\n  protected generateTriggerStatement(\n    tableName: string,\n    trigger: TriggerDefinition,\n  ): string {\n    // For simple triggers, we need to create a function first\n    // This is PostgreSQL's two-step trigger process\n\n    // Check if this is an updated_at trigger\n    if (trigger.name.includes('updated_at')) {\n      // Generate the function and trigger for updated_at\n      const functionName = `update_${tableName}_updated_at`;\n\n      let sql = `-- Function for ${trigger.name}\\n`;\n      sql += `CREATE OR REPLACE FUNCTION ${functionName}()\\n`;\n      sql += `RETURNS TRIGGER AS $$\\n`;\n      sql += `BEGIN\\n`;\n      sql += `  NEW.updated_at = CURRENT_TIMESTAMP;\\n`;\n      sql += `  RETURN NEW;\\n`;\n      sql += `END;\\n`;\n      sql += `$$ LANGUAGE plpgsql;\\n\\n`;\n\n      sql += `-- Trigger\\n`;\n      sql += `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n      sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n      sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n      sql += `FOR EACH ROW\\n`;\n      sql += `EXECUTE FUNCTION ${functionName}();`;\n\n      return sql;\n    }\n\n    // For custom triggers, use the provided body\n    let sql = `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n    sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n    sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n    sql += `FOR EACH ROW\\n`;\n\n    if (trigger.condition) {\n      sql += `WHEN (${trigger.condition})\\n`;\n    }\n\n    // PostgreSQL triggers need EXECUTE FUNCTION or EXECUTE PROCEDURE\n    // If body contains a function call, use it directly\n    if (trigger.body.includes('EXECUTE')) {\n      sql += trigger.body;\n    } else {\n      // Wrap in anonymous DO block or assume it's a function name\n      sql += `EXECUTE FUNCTION ${trigger.body}`;\n    }\n\n    return `${sql};`;\n  }\n\n  /**\n   * PostgreSQL supports triggers\n   */\n  supportsTriggers(): boolean {\n    return true;\n  }\n\n  /**\n   * PostgreSQL doesn't require inline UNIQUE for UPSERT\n   * Both inline and separate indexes work with ON CONFLICT\n   */\n  requiresInlineUnique(): boolean {\n    return false;\n  }\n}\n"],"mappings":";;AAeA,IAAa,mBAAb,cAAsC,gBAAgB;CACpD,SAAkC;;;;;;CAOlC,QAAQ,MAA2B;EACjC,QAAQ,MAAR;GACE,KAAK,QACH,OAAO;GACT,KAAK,aAIH,OAAO;GACT,KAAK,QACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,SACE,OAAO,MAAM,QAAQ,IAAI;EAC7B;CACF;;;;;;;CAQA,yBACE,WACA,SACQ;EAKR,IAAI,QAAQ,KAAK,SAAS,YAAY,GAAG;GAEvC,MAAM,eAAe,UAAU,UAAU;GAEzC,IAAI,MAAM,mBAAmB,QAAQ,KAAK;GAC1C,OAAO,8BAA8B,aAAa;GAClD,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GAEP,OAAO;GACP,OAAO,2BAA2B,QAAQ,KAAK,QAAQ,UAAU;GACjE,OAAO,mBAAmB,QAAQ,KAAK;GACvC,OAAO,GAAG,QAAQ,KAAK,GAAG,QAAQ,MAAM,OAAO,UAAU;GACzD,OAAO;GACP,OAAO,oBAAoB,aAAa;GAExC,OAAO;EACT;EAGA,IAAI,MAAM,2BAA2B,QAAQ,KAAK,QAAQ,UAAU;EACpE,OAAO,mBAAmB,QAAQ,KAAK;EACvC,OAAO,GAAG,QAAQ,KAAK,GAAG,QAAQ,MAAM,OAAO,UAAU;EACzD,OAAO;EAEP,IAAI,QAAQ,WACV,OAAO,SAAS,QAAQ,UAAU;EAKpC,IAAI,QAAQ,KAAK,SAAS,SAAS,GACjC,OAAO,QAAQ;OAGf,OAAO,oBAAoB,QAAQ;EAGrC,OAAO,GAAG,IAAI;CAChB;;;;CAKA,mBAA4B;EAC1B,OAAO;CACT;;;;;CAMA,uBAAgC;EAC9B,OAAO;CACT;AACF"}
+{"version":3,"file":"postgres-strategy.js","names":[],"sources":["../../../src/schema/ddl/postgres-strategy.ts"],"sourcesContent":["/**\n * PostgreSQL DDL Strategy\n *\n * PostgreSQL-specific DDL generation with the following characteristics:\n * - JSONB type for JSON columns (more efficient than JSON)\n * - Native BOOLEAN type\n * - Full trigger support with PL/pgSQL functions\n * - UNIQUE can be inline or separate indexes\n * - Supports CAST in DEFAULT values\n */\n\nimport { shortenIdentifier } from '../index-utils.js';\nimport type { SQLDataType, TriggerDefinition } from '../types.js';\nimport { BaseDDLStrategy } from './base-strategy.js';\nimport type { DatabaseEngine } from './types.js';\n\nexport class PostgresStrategy extends BaseDDLStrategy {\n  readonly engine: DatabaseEngine = 'postgres';\n\n  /**\n   * Map types for PostgreSQL\n   * - JSON → JSONB (more efficient, supports indexing)\n   * - TIMESTAMP → TIMESTAMP WITH TIME ZONE (best practice)\n   */\n  mapType(type: SQLDataType): string {\n    switch (type) {\n      case 'JSON':\n        return 'JSONB'; // PostgreSQL JSONB is more efficient\n      case 'TIMESTAMP':\n        // JavaScript Date represents an instant. Preserve that contract in\n        // PostgreSQL instead of discarding the ISO offset in a timezone-naive\n        // TIMESTAMP column and reinterpreting the wall time at hydration.\n        return 'TIMESTAMPTZ';\n      case 'REAL':\n        return 'DOUBLE PRECISION'; // PostgreSQL convention\n      case 'UUID':\n        return 'uuid'; // Native 16-byte uuid (R11) — vs 37-byte text\n      default:\n        return super.mapType(type);\n    }\n  }\n\n  /**\n   * Generate trigger for PostgreSQL\n   *\n   * PostgreSQL triggers require a separate function, then the trigger.\n   * For updated_at timestamps, we generate both.\n   */\n  protected generateTriggerStatement(\n    tableName: string,\n    trigger: TriggerDefinition,\n  ): string {\n    // For simple triggers, we need to create a function first\n    // This is PostgreSQL's two-step trigger process\n\n    // Check if this is an updated_at trigger\n    if (trigger.name.includes('updated_at')) {\n      // Generate the function and trigger for updated_at. The function name is\n      // a PostgreSQL identifier like any other, so it is subject to the same\n      // 63-byte limit — and unlike an index it is *referenced* by the trigger\n      // below, so a truncation that CREATE FUNCTION accepts would leave\n      // EXECUTE FUNCTION pointing at a name PostgreSQL never stored (#2374).\n      const functionName = shortenIdentifier(`update_${tableName}_updated_at`);\n\n      let sql = `-- Function for ${trigger.name}\\n`;\n      sql += `CREATE OR REPLACE FUNCTION ${functionName}()\\n`;\n      sql += `RETURNS TRIGGER AS $$\\n`;\n      sql += `BEGIN\\n`;\n      sql += `  NEW.updated_at = CURRENT_TIMESTAMP;\\n`;\n      sql += `  RETURN NEW;\\n`;\n      sql += `END;\\n`;\n      sql += `$$ LANGUAGE plpgsql;\\n\\n`;\n\n      sql += `-- Trigger\\n`;\n      sql += `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n      sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n      sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n      sql += `FOR EACH ROW\\n`;\n      sql += `EXECUTE FUNCTION ${functionName}();`;\n\n      return sql;\n    }\n\n    // For custom triggers, use the provided body\n    let sql = `DROP TRIGGER IF EXISTS \"${trigger.name}\" ON \"${tableName}\";\\n`;\n    sql += `CREATE TRIGGER \"${trigger.name}\"\\n`;\n    sql += `${trigger.when} ${trigger.event} ON \"${tableName}\"\\n`;\n    sql += `FOR EACH ROW\\n`;\n\n    if (trigger.condition) {\n      sql += `WHEN (${trigger.condition})\\n`;\n    }\n\n    // PostgreSQL triggers need EXECUTE FUNCTION or EXECUTE PROCEDURE\n    // If body contains a function call, use it directly\n    if (trigger.body.includes('EXECUTE')) {\n      sql += trigger.body;\n    } else {\n      // Wrap in anonymous DO block or assume it's a function name\n      sql += `EXECUTE FUNCTION ${trigger.body}`;\n    }\n\n    return `${sql};`;\n  }\n\n  /**\n   * PostgreSQL supports triggers\n   */\n  supportsTriggers(): boolean {\n    return true;\n  }\n\n  /**\n   * PostgreSQL doesn't require inline UNIQUE for UPSERT\n   * Both inline and separate indexes work with ON CONFLICT\n   */\n  requiresInlineUnique(): boolean {\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,IAAa,mBAAb,cAAsC,gBAAgB;CACpD,SAAkC;;;;;;CAOlC,QAAQ,MAA2B;EACjC,QAAQ,MAAR;GACE,KAAK,QACH,OAAO;GACT,KAAK,aAIH,OAAO;GACT,KAAK,QACH,OAAO;GACT,KAAK,QACH,OAAO;GACT,SACE,OAAO,MAAM,QAAQ,IAAI;EAC7B;CACF;;;;;;;CAQA,yBACE,WACA,SACQ;EAKR,IAAI,QAAQ,KAAK,SAAS,YAAY,GAAG;GAMvC,MAAM,eAAe,kBAAkB,UAAU,UAAU,YAAY;GAEvE,IAAI,MAAM,mBAAmB,QAAQ,KAAK;GAC1C,OAAO,8BAA8B,aAAa;GAClD,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GAEP,OAAO;GACP,OAAO,2BAA2B,QAAQ,KAAK,QAAQ,UAAU;GACjE,OAAO,mBAAmB,QAAQ,KAAK;GACvC,OAAO,GAAG,QAAQ,KAAK,GAAG,QAAQ,MAAM,OAAO,UAAU;GACzD,OAAO;GACP,OAAO,oBAAoB,aAAa;GAExC,OAAO;EACT;EAGA,IAAI,MAAM,2BAA2B,QAAQ,KAAK,QAAQ,UAAU;EACpE,OAAO,mBAAmB,QAAQ,KAAK;EACvC,OAAO,GAAG,QAAQ,KAAK,GAAG,QAAQ,MAAM,OAAO,UAAU;EACzD,OAAO;EAEP,IAAI,QAAQ,WACV,OAAO,SAAS,QAAQ,UAAU;EAKpC,IAAI,QAAQ,KAAK,SAAS,SAAS,GACjC,OAAO,QAAQ;OAGf,OAAO,oBAAoB,QAAQ;EAGrC,OAAO,GAAG,IAAI;CAChB;;;;CAKA,mBAA4B;EAC1B,OAAO;CACT;;;;;CAMA,uBAAgC;EAC9B,OAAO;CACT;AACF"}