tempest-db-js 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -1751,7 +1751,8 @@ function createPostgresDriver(url, pool) {
 var DEFAULT_FLAGS = {
   primaryKey: false,
   notNull: false,
-  hasDefault: false
+  hasDefault: false,
+  unique: false
 };
 var sql = {
   /** Current timestamp at insert (`CURRENT_TIMESTAMP` / `now()`). */
@@ -1771,23 +1772,38 @@ var sql = {
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
 }
+function parseReference(ref, options) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0 || dot === ref.length - 1) {
+    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
+  }
+  return {
+    table: ref.slice(0, dot),
+    column: ref.slice(dot + 1),
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
 var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null) {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null) {
     this.type = type;
     this.flags = flags;
     this.defaultValue = defaultValue;
     this.onUpdateValue = onUpdateValue;
+    this.reference = reference;
   }
   type;
   flags;
   defaultValue;
   onUpdateValue;
+  reference;
   primaryKey() {
     return new _Column(
       this.type,
       { ...this.flags, primaryKey: true, hasDefault: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   notNull() {
@@ -1795,7 +1811,40 @@ var Column = class _Column {
       this.type,
       { ...this.flags, notNull: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
+   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
+   */
+  unique() {
+    return new _Column(
+      this.type,
+      { ...this.flags, unique: true },
+      this.defaultValue,
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
+   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
+   * not change the inferred type.
+   *
+   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
+   * @param options Optional `onDelete` / `onUpdate` referential actions.
+   * @returns A new column carrying the reference.
+   * @throws Error When `ref` is not a valid `"table.column"` string.
+   */
+  references(ref, options) {
+    return new _Column(
+      this.type,
+      this.flags,
+      this.defaultValue,
+      this.onUpdateValue,
+      parseReference(ref, options)
     );
   }
   /**
@@ -1808,7 +1857,8 @@ var Column = class _Column {
       this.type,
       { ...this.flags, hasDefault: true },
       resolved,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   /**
@@ -1817,7 +1867,7 @@ var Column = class _Column {
    */
   onUpdate(value) {
     const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+    return new _Column(this.type, this.flags, this.defaultValue, resolved, this.reference);
   }
 };
 function makeColumn(kind, meta = {}) {
@@ -1871,8 +1921,36 @@ var column = {
   /** `ENUM(...values)` → a string-literal union of the given values. */
   enum: (...values) => makeColumn("enum", { values })
 };
+function unique(...columns) {
+  if (columns.length === 0) {
+    throw new Error("unique() requires at least one column.");
+  }
+  return { kind: "unique", columns };
+}
+function foreignKey(columns, refTable, refColumns, options) {
+  if (columns.length === 0 || columns.length !== refColumns.length) {
+    throw new Error(
+      "foreignKey() requires matching, non-empty local and referenced column lists."
+    );
+  }
+  return {
+    kind: "foreignKey",
+    name: options?.name,
+    columns,
+    refTable,
+    refColumns,
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
 var Model = class {
   static tablename;
+  /**
+   * Optional table-level constraints (composite unique / foreign keys), returned
+   * by a thunk so forward references resolve lazily. Mirrors SQLAlchemy's
+   * `__table_args__`.
+   */
+  static tableArgs;
 };
 var columnsCache = /* @__PURE__ */ new WeakMap();
 function columnsOf(model) {
@@ -1927,6 +2005,7 @@ exports.createEngine = createEngine;
 exports.createSyncEngine = createSyncEngine;
 exports.del = del;
 exports.detectDialect = detectDialect;
+exports.foreignKey = foreignKey;
 exports.fromDict = fromDict;
 exports.getDialect = getDialect;
 exports.hasMany = hasMany;
@@ -1947,6 +2026,7 @@ exports.sum = sum;
 exports.toCondNode = toCondNode;
 exports.toDict = toDict;
 exports.toJSON = toJSON;
+exports.unique = unique;
 exports.update = update;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map