@type32/tauri-sqlite-orm 0.2.15 → 0.3.0

package/dist/index.js

@@ -53,6 +53,8 @@ __export(index_exports, {
   contains: () => contains,
   count: () => count,
   countDistinct: () => countDistinct,
+  defineRelations: () => defineRelations,
+  defineRelationsPart: () => defineRelationsPart,
   desc: () => desc,
   endsWith: () => endsWith,
   enumType: () => enumType,
@@ -92,12 +94,13 @@ __export(index_exports, {
   startsWith: () => startsWith,
   subquery: () => subquery,
   sum: () => sum,
-  text: () => text
+  text: () => text,
+  through: () => through
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/orm.ts
-var import_kysely4 = require("kysely");
+var import_kysely5 = require("kysely");
 
 // src/dialect.ts
 var import_kysely = require("kysely");
@@ -168,6 +171,9 @@ var TauriDialect = class {
 };
 
 // src/builders/select.ts
+var import_kysely3 = require("kysely");
+
+// src/operators.ts
 var import_kysely2 = require("kysely");
 
 // src/serialization.ts
@@ -271,6 +277,83 @@ function deserializeValue(value, column) {
   return value;
 }
 
+// src/operators.ts
+var eq = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(colRef)} = ${import_kysely2.sql.val(serialized)}`;
+};
+var ne = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(colRef)} != ${import_kysely2.sql.val(serialized)}`;
+};
+var and = (...conditions) => {
+  if (conditions.length === 0) return import_kysely2.sql`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return import_kysely2.sql`(${import_kysely2.sql.join(conditions.map((c) => import_kysely2.sql`(${c})`), import_kysely2.sql` AND `)})`;
+};
+var or = (...conditions) => {
+  if (conditions.length === 0) return import_kysely2.sql`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return import_kysely2.sql`(${import_kysely2.sql.join(conditions.map((c) => import_kysely2.sql`(${c})`), import_kysely2.sql` OR `)})`;
+};
+var not = (condition) => import_kysely2.sql`NOT (${condition})`;
+var gt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} > ${import_kysely2.sql.val(serialized)}`;
+};
+var gte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} >= ${import_kysely2.sql.val(serialized)}`;
+};
+var lt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} < ${import_kysely2.sql.val(serialized)}`;
+};
+var lte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} <= ${import_kysely2.sql.val(serialized)}`;
+};
+var like = (column, pattern) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} LIKE ${import_kysely2.sql.val(pattern)}`;
+var ilike = (column, pattern) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} LIKE ${import_kysely2.sql.val(pattern)} COLLATE NOCASE`;
+var startsWith = (column, value) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} LIKE ${import_kysely2.sql.val(`${value}%`)}`;
+var endsWith = (column, value) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} LIKE ${import_kysely2.sql.val(`%${value}`)}`;
+var contains = (column, value) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} LIKE ${import_kysely2.sql.val(`%${value}%`)}`;
+var isNull = (column) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} IS NULL`;
+var isNotNull = (column) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} IS NOT NULL`;
+var exists = (subquery2) => import_kysely2.sql`EXISTS ${subquery2}`;
+var notExists = (subquery2) => import_kysely2.sql`NOT EXISTS ${subquery2}`;
+var eqSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} = (${subquery2})`;
+var neSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} != (${subquery2})`;
+var gtSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} > (${subquery2})`;
+var gteSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} >= (${subquery2})`;
+var ltSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} < (${subquery2})`;
+var lteSubquery = (column, subquery2) => import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} <= (${subquery2})`;
+var inArray = (column, values) => {
+  if ((0, import_kysely2.isExpression)(values)) {
+    return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return import_kysely2.sql`1 = 0`;
+  const serialized = arr.map((v) => import_kysely2.sql.val(serializeValue(v, column)));
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} IN (${import_kysely2.sql.join(serialized)})`;
+};
+var notIn = (column, values) => {
+  if ((0, import_kysely2.isExpression)(values)) {
+    return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} NOT IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return import_kysely2.sql`1 = 1`;
+  const serialized = arr.map((v) => import_kysely2.sql.val(serializeValue(v, column)));
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} NOT IN (${import_kysely2.sql.join(serialized)})`;
+};
+var between = (column, min2, max2) => {
+  const serializedMin = serializeValue(min2, column);
+  const serializedMax = serializeValue(max2, column);
+  return import_kysely2.sql`${import_kysely2.sql.ref(column._.name)} BETWEEN ${import_kysely2.sql.val(serializedMin)} AND ${import_kysely2.sql.val(serializedMax)}`;
+};
+
 // src/builders/select.ts
 function getDbNameToTsName(table) {
   const map = {};
@@ -332,7 +415,7 @@ var SelectQueryBuilder = class {
       this._builder = this._builder.orderBy(column, direction);
     } else {
       this._builder = this._builder.orderBy(
-        import_kysely2.sql.ref(column._.name),
+        import_kysely3.sql.ref(column._.name),
         direction
       );
     }
@@ -349,7 +432,7 @@ var SelectQueryBuilder = class {
   groupBy(...columns) {
     for (const col of columns) {
       this._builder = this._builder.groupBy(
-        import_kysely2.sql`${import_kysely2.sql.ref(this._table._.name)}.${import_kysely2.sql.ref(col._.name)}`
+        import_kysely3.sql`${import_kysely3.sql.ref(this._table._.name)}.${import_kysely3.sql.ref(col._.name)}`
       );
     }
     return this;
@@ -400,32 +483,62 @@ var SelectQueryBuilder = class {
           (col) => `${foreignAlias}.${col._.name} as "${foreignAlias}.${col._.name}"`
         );
         if (relation.type === "one" && relation.fields && relation.references) {
-          const onCondition = import_kysely2.sql`${import_kysely2.sql.join(
+          const onCondition = import_kysely3.sql`${import_kysely3.sql.join(
             relation.fields.map(
-              (field, i) => import_kysely2.sql`${import_kysely2.sql.ref(`${parentAlias}.${field._.name}`)} = ${import_kysely2.sql.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`
+              (field, i) => import_kysely3.sql`${import_kysely3.sql.ref(`${parentAlias}.${field._.name}`)} = ${import_kysely3.sql.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`
             ),
-            import_kysely2.sql` AND `
+            import_kysely3.sql` AND `
           )}`;
           this._builder = this._builder.leftJoin(
             `${foreignTable._.name} as ${foreignAlias}`,
             (join) => join.on(onCondition)
           ).select(aliasedCols);
         } else if (relation.type === "many") {
-          const refRelation = Object.entries(foreignTable.relations).find(
-            ([, r]) => r.foreignTable === parentTable
-          );
-          if (refRelation && refRelation[1].fields && refRelation[1].references) {
-            const [, relationConfig] = refRelation;
-            const onCondition = import_kysely2.sql`${import_kysely2.sql.join(
-              relationConfig.fields.map(
-                (field, i) => import_kysely2.sql`${import_kysely2.sql.ref(`${foreignAlias}.${field._.name}`)} = ${import_kysely2.sql.ref(`${parentAlias}.${relationConfig.references[i]._.name}`)}`
-              ),
-              import_kysely2.sql` AND `
-            )}`;
+          if (relation.junctionTable && relation.fromJunction && relation.toJunction) {
+            const junctionTable = relation.junctionTable;
+            const junctionAlias = `${foreignAlias}_jn`;
+            const fromJ = relation.fromJunction;
+            const toJ = relation.toJunction;
+            const join1 = import_kysely3.sql`${import_kysely3.sql.ref(`${parentAlias}.${fromJ.column._.name}`)} = ${import_kysely3.sql.ref(`${junctionAlias}.${fromJ.junctionColumn._.name}`)}`;
+            let join2 = import_kysely3.sql`${import_kysely3.sql.ref(`${junctionAlias}.${toJ.junctionColumn._.name}`)} = ${import_kysely3.sql.ref(`${foreignAlias}.${toJ.column._.name}`)}`;
+            if (relation.where) {
+              join2 = and(join2, relation.where(foreignAlias));
+            }
             this._builder = this._builder.leftJoin(
+              `${junctionTable._.name} as ${junctionAlias}`,
+              (join) => join.on(join1)
+            ).leftJoin(
               `${foreignTable._.name} as ${foreignAlias}`,
-              (join) => join.on(onCondition)
+              (join) => join.on(join2)
             ).select(aliasedCols);
+          } else {
+            let fields = relation.fields;
+            let references = relation.references;
+            if (!fields || !references) {
+              const refRelation = Object.entries(foreignTable.relations).find(
+                ([, r]) => r.foreignTable === parentTable
+              );
+              if (refRelation && refRelation[1].fields && refRelation[1].references) {
+                const [, relationConfig] = refRelation;
+                fields = relationConfig.fields;
+                references = relationConfig.references;
+              }
+            }
+            if (fields && references) {
+              let onCondition = import_kysely3.sql`${import_kysely3.sql.join(
+                fields.map(
+                  (field, i) => import_kysely3.sql`${import_kysely3.sql.ref(`${foreignAlias}.${field._.name}`)} = ${import_kysely3.sql.ref(`${parentAlias}.${references[i]._.name}`)}`
+                ),
+                import_kysely3.sql` AND `
+              )}`;
+              if (relation.where) {
+                onCondition = and(onCondition, relation.where(foreignAlias));
+              }
+              this._builder = this._builder.leftJoin(
+                `${foreignTable._.name} as ${foreignAlias}`,
+                (join) => join.on(onCondition)
+              ).select(aliasedCols);
+            }
           }
         }
         if (typeof include === "object" && include.with) {
@@ -521,6 +634,7 @@ var SelectQueryBuilder = class {
           const column = this._table._.columns[tsName];
           result[tsName] = column ? deserializeValue(value, column) : value;
         } else {
+          if (tableAlias.endsWith("_jn")) continue;
           const path = parseRelationPath(tableAlias, this._table._.name);
           if (path.length > 0) {
             const relationConfig = getNestedRelation(this._table, path);
@@ -599,12 +713,12 @@ var SelectQueryBuilder = class {
   }
   async exists() {
     this.applyIncludes();
-    const compiledResult = await this._builder.clearSelect().select(import_kysely2.sql.raw("1").as("__exists__")).limit(1).execute();
+    const compiledResult = await this._builder.clearSelect().select(import_kysely3.sql.raw("1").as("__exists__")).limit(1).execute();
     return compiledResult.length > 0;
   }
   async count() {
     this.applyIncludes();
-    const result = await this._builder.clearSelect().select(import_kysely2.sql`COUNT(*)`.as("count")).execute();
+    const result = await this._builder.clearSelect().select(import_kysely3.sql`COUNT(*)`.as("count")).execute();
     const row = result[0];
     const val = row ? row['"count"'] ?? row.count : void 0;
     return Number(val ?? 0);
@@ -614,7 +728,7 @@ var SelectQueryBuilder = class {
     const col = this._table._.columns[column];
     const alias2 = col._.name;
     const results = await this._builder.clearSelect().select(
-      import_kysely2.sql.raw(`${this._table._.name}.${alias2}`).as(alias2)
+      import_kysely3.sql.raw(`${this._table._.name}.${alias2}`).as(alias2)
     ).execute();
     return results.map((row) => {
       const val = row['"' + alias2 + '"'] ?? row[alias2];
@@ -650,7 +764,7 @@ var SelectQueryBuilder = class {
 };
 
 // src/builders/update.ts
-var import_kysely3 = require("kysely");
+var import_kysely4 = require("kysely");
 
 // src/errors.ts
 var TauriORMError = class extends Error {
@@ -803,7 +917,7 @@ var UpdateQueryBuilder = class {
     }
     for (const op of this._incrementDecrementOps) {
       const sign = op.op === "increment" ? "+" : "-";
-      setMap[op.column] = import_kysely3.sql.raw(`${op.column} ${sign} ${op.value}`);
+      setMap[op.column] = import_kysely4.sql.raw(`${op.column} ${sign} ${op.value}`);
     }
     return setMap;
   }
@@ -1181,12 +1295,12 @@ var Table = class {
 var sqliteTable = (tableName, columns) => {
   return new Table(tableName, columns);
 };
-var asc = (column) => import_kysely4.sql`${import_kysely4.sql.ref(column._.name)} ASC`;
-var desc = (column) => import_kysely4.sql`${import_kysely4.sql.ref(column._.name)} DESC`;
+var asc = (column) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} ASC`;
+var desc = (column) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} DESC`;
 var TauriORM = class {
   constructor(db, schema = void 0) {
     this.db = db;
-    this.kysely = new import_kysely4.Kysely({ dialect: new TauriDialect(db) });
+    this.kysely = new import_kysely5.Kysely({ dialect: new TauriDialect(db) });
     if (schema) {
       for (const [, value] of Object.entries(schema)) {
         if (value instanceof Table) {
@@ -1575,8 +1689,9 @@ var OneRelation = class extends Relation {
   }
 };
 var ManyRelation = class extends Relation {
-  constructor(foreignTable) {
+  constructor(foreignTable, config) {
     super(foreignTable);
+    this.config = config;
   }
 };
 var relations = (table, relationsCallback) => {
@@ -1594,7 +1709,9 @@ var relations = (table, relationsCallback) => {
         type: "one",
         foreignTable: relation.foreignTable,
         fields: relation.config?.fields,
-        references: relation.config?.references
+        references: relation.config?.references,
+        optional: relation.config?.optional,
+        alias: relation.config?.alias
       };
     } else if (relation instanceof ManyRelation) {
       table.relations[name] = {
@@ -1612,84 +1729,6 @@ var alias = (table, alias2) => {
   return table;
 };
 
-// src/operators.ts
-var import_kysely5 = require("kysely");
-var eq = (column, value, tableAlias) => {
-  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(colRef)} = ${import_kysely5.sql.val(serialized)}`;
-};
-var ne = (column, value, tableAlias) => {
-  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(colRef)} != ${import_kysely5.sql.val(serialized)}`;
-};
-var and = (...conditions) => {
-  if (conditions.length === 0) return import_kysely5.sql`1 = 1`;
-  if (conditions.length === 1) return conditions[0];
-  return import_kysely5.sql`(${import_kysely5.sql.join(conditions.map((c) => import_kysely5.sql`(${c})`), import_kysely5.sql` AND `)})`;
-};
-var or = (...conditions) => {
-  if (conditions.length === 0) return import_kysely5.sql`1 = 1`;
-  if (conditions.length === 1) return conditions[0];
-  return import_kysely5.sql`(${import_kysely5.sql.join(conditions.map((c) => import_kysely5.sql`(${c})`), import_kysely5.sql` OR `)})`;
-};
-var not = (condition) => import_kysely5.sql`NOT (${condition})`;
-var gt = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} > ${import_kysely5.sql.val(serialized)}`;
-};
-var gte = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} >= ${import_kysely5.sql.val(serialized)}`;
-};
-var lt = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} < ${import_kysely5.sql.val(serialized)}`;
-};
-var lte = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} <= ${import_kysely5.sql.val(serialized)}`;
-};
-var like = (column, pattern) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} LIKE ${import_kysely5.sql.val(pattern)}`;
-var ilike = (column, pattern) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} LIKE ${import_kysely5.sql.val(pattern)} COLLATE NOCASE`;
-var startsWith = (column, value) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} LIKE ${import_kysely5.sql.val(`${value}%`)}`;
-var endsWith = (column, value) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} LIKE ${import_kysely5.sql.val(`%${value}`)}`;
-var contains = (column, value) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} LIKE ${import_kysely5.sql.val(`%${value}%`)}`;
-var isNull = (column) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} IS NULL`;
-var isNotNull = (column) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} IS NOT NULL`;
-var exists = (subquery2) => import_kysely5.sql`EXISTS ${subquery2}`;
-var notExists = (subquery2) => import_kysely5.sql`NOT EXISTS ${subquery2}`;
-var eqSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} = (${subquery2})`;
-var neSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} != (${subquery2})`;
-var gtSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} > (${subquery2})`;
-var gteSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} >= (${subquery2})`;
-var ltSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} < (${subquery2})`;
-var lteSubquery = (column, subquery2) => import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} <= (${subquery2})`;
-var inArray = (column, values) => {
-  if ((0, import_kysely5.isExpression)(values)) {
-    return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} IN (${values})`;
-  }
-  const arr = values;
-  if (arr.length === 0) return import_kysely5.sql`1 = 0`;
-  const serialized = arr.map((v) => import_kysely5.sql.val(serializeValue(v, column)));
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} IN (${import_kysely5.sql.join(serialized)})`;
-};
-var notIn = (column, values) => {
-  if ((0, import_kysely5.isExpression)(values)) {
-    return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} NOT IN (${values})`;
-  }
-  const arr = values;
-  if (arr.length === 0) return import_kysely5.sql`1 = 1`;
-  const serialized = arr.map((v) => import_kysely5.sql.val(serializeValue(v, column)));
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} NOT IN (${import_kysely5.sql.join(serialized)})`;
-};
-var between = (column, min2, max2) => {
-  const serializedMin = serializeValue(min2, column);
-  const serializedMax = serializeValue(max2, column);
-  return import_kysely5.sql`${import_kysely5.sql.ref(column._.name)} BETWEEN ${import_kysely5.sql.val(serializedMin)} AND ${import_kysely5.sql.val(serializedMax)}`;
-};
-
 // src/aggregates.ts
 var import_kysely6 = require("kysely");
 var count = (column) => import_kysely6.sql`COUNT(${column ? import_kysely6.sql.ref(column._.name) : import_kysely6.sql.raw("*")})`;
@@ -1726,6 +1765,126 @@ function numeric(name, config) {
 }
 var enumType = (name, values) => text(name, { enum: values });
 
+// src/relations-v2.ts
+function extractTables(schema) {
+  const tables = {};
+  for (const [key, value] of Object.entries(schema)) {
+    const v = value;
+    if (v && typeof v === "object" && v._?.name && v._?.columns && typeof v.relations === "object") {
+      tables[key] = v;
+    }
+  }
+  return tables;
+}
+function through(column, junctionColumn, junctionTable) {
+  return { column, junctionColumn, junctionTable };
+}
+function toArray(col) {
+  return Array.isArray(col) ? col : [col];
+}
+function isThroughRef(v) {
+  return v && typeof v === "object" && "column" in v && "junctionColumn" in v && "junctionTable" in v;
+}
+function buildTableRef(table) {
+  return { ...table._.columns };
+}
+function buildR(tables) {
+  const tableRefs = {};
+  const oneFns = {};
+  const manyFns = {};
+  for (const [tableKey, table] of Object.entries(tables)) {
+    tableRefs[tableKey] = buildTableRef(table);
+    const foreignTable = table;
+    oneFns[tableKey] = (opts) => {
+      return new OneRelation(foreignTable, {
+        fields: toArray(opts.from),
+        references: toArray(opts.to),
+        optional: opts.optional,
+        alias: opts.alias
+      });
+    };
+    manyFns[tableKey] = (opts) => {
+      if (!opts?.from || !opts?.to) return new ManyRelation(foreignTable);
+      if (isThroughRef(opts.from) && isThroughRef(opts.to)) {
+        return new ManyRelation(foreignTable, {
+          through: {
+            junctionTable: opts.from.junctionTable,
+            fromRef: { column: opts.from.column, junctionColumn: opts.from.junctionColumn },
+            toRef: { column: opts.to.column, junctionColumn: opts.to.junctionColumn }
+          },
+          optional: opts.optional,
+          alias: opts.alias,
+          where: opts.where
+        });
+      }
+      return new ManyRelation(foreignTable, {
+        from: toArray(opts.from),
+        to: toArray(opts.to),
+        optional: opts.optional,
+        alias: opts.alias,
+        where: opts.where
+      });
+    };
+  }
+  return {
+    ...tableRefs,
+    one: oneFns,
+    many: manyFns
+  };
+}
+function applyRelationsToTables(tables, relationsResult) {
+  for (const [tableKey, rels] of Object.entries(relationsResult)) {
+    const table = tables[tableKey];
+    if (!table) continue;
+    for (const [relName, relation] of Object.entries(rels)) {
+      if (relation instanceof OneRelation) {
+        table.relations[relName] = {
+          type: "one",
+          foreignTable: relation.foreignTable,
+          fields: relation.config?.fields,
+          references: relation.config?.references,
+          optional: relation.config?.optional,
+          alias: relation.config?.alias
+        };
+      } else if (relation instanceof ManyRelation) {
+        const config = relation.config;
+        if (config?.through) {
+          table.relations[relName] = {
+            type: "many",
+            foreignTable: relation.foreignTable,
+            junctionTable: config.through.junctionTable,
+            fromJunction: config.through.fromRef,
+            toJunction: config.through.toRef,
+            optional: config.optional,
+            alias: config.alias,
+            where: config.where
+          };
+        } else {
+          table.relations[relName] = {
+            type: "many",
+            foreignTable: relation.foreignTable,
+            fields: config ? config.to : void 0,
+            references: config ? config.from : void 0,
+            optional: config?.optional,
+            alias: config?.alias,
+            where: config?.where
+          };
+        }
+      }
+    }
+  }
+}
+function defineRelations(schema, callback) {
+  const tables = extractTables(schema);
+  const r = buildR(tables);
+  const result = callback(r);
+  applyRelationsToTables(tables, result);
+  return result;
+}
+function defineRelationsPart(schema, callback) {
+  return defineRelations(schema, callback);
+}
+
 // src/index.ts
 var import_kysely7 = require("kysely");
 // Annotate the CommonJS export names for ESM import in node:
@@ -1763,6 +1922,8 @@ var import_kysely7 = require("kysely");
   contains,
   count,
   countDistinct,
+  defineRelations,
+  defineRelationsPart,
   desc,
   endsWith,
   enumType,
@@ -1802,5 +1963,6 @@ var import_kysely7 = require("kysely");
   startsWith,
   subquery,
   sum,
-  text
+  text,
+  through
 });