@simplysm/orm-common 13.0.76 → 13.0.77

package/tests/ddl/relation-builder.spec.ts

@@ -36,7 +36,7 @@ describe("DDL - Relation Builder", () => {
     const fkBuilder = RelationFactory.foreignKey(["userId"], () => User);
 
     const db = createTestDb();
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
       fkBuilder,
@@ -44,7 +44,7 @@ describe("DDL - Relation Builder", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: {
           name: "FK_Post_user",
@@ -88,7 +88,7 @@ describe("DDL - Relation Builder", () => {
     const fkBuilder = RelationFactory.foreignKey(["companyId", "companyRegionId"], () => Company);
 
     const db = createTestDb();
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Employee" },
       "company",
       fkBuilder,
@@ -96,7 +96,7 @@ describe("DDL - Relation Builder", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
         foreignKey: {
           name: "FK_Employee_company",

package/tests/dml/update.spec.ts

@@ -202,14 +202,14 @@ describe("FK switch", () => {
 
     const def = db.getSwitchFkQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Employee" },
-      "off",
+      false,
     );
 
     it("Verify QueryDef", () => {
       expect(def).toEqual({
         type: "switchFk",
         table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        switch: "off",
+        enabled: false,
       });
     });
 

package/tests/expr/conditional.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-export const ifNull: ExpectedSql = {
+export const coalesce: ExpectedSql = {
   mysql: mysql`
     SELECT COALESCE(\`T1\`.\`name\`, 'Unknown') AS \`nameOrDefault\`
     FROM \`TestDb\`.\`User\` AS \`T1\`
@@ -118,7 +118,7 @@ export const least: ExpectedSql = {
   `,
 };
 
-export const ifNullMultiple: ExpectedSql = {
+export const coalesceMultiple: ExpectedSql = {
   mysql: mysql`
     SELECT COALESCE(\`T1\`.\`email\`, \`T1\`.\`name\`, 'Anonymous') AS \`firstValid\`
     FROM \`TestDb\`.\`User\` AS \`T1\`

package/tests/expr/conditional.spec.ts

@@ -7,19 +7,19 @@ import "../setup/test-utils"; // toMatchSql matcher
 import * as expected from "./conditional.expected";
 
 describe("Expr - Conditional functions", () => {
-  describe("ifNull - null replacement", () => {
+  describe("coalesce - null replacement", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        nameOrDefault: expr.ifNull(item.name, "Unknown"),
+        nameOrDefault: expr.coalesce(item.name, "Unknown"),
       }))
       .getSelectQueryDef();
 
     it("Verify QueryDef", () => {
       expect(def.select).toMatchObject({
         nameOrDefault: {
-          type: "ifNull",
+          type: "coalesce",
           args: [
             { type: "column", path: ["T1", "name"] },
             { type: "value", value: "Unknown" },
@@ -30,7 +30,7 @@ describe("Expr - Conditional functions", () => {
 
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ifNull[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.coalesce[dialect]);
     });
   });
 
@@ -219,19 +219,19 @@ describe("Expr - Conditional functions", () => {
     });
   });
 
-  describe("ifNull - create COALESCE with 3+ arguments", () => {
+  describe("coalesce - create COALESCE with 3+ arguments", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        firstValid: expr.ifNull(item.email, item.name, "Anonymous"),
+        firstValid: expr.coalesce(item.email, item.name, "Anonymous"),
       }))
       .getSelectQueryDef();
 
     it("Verify QueryDef", () => {
       expect(def.select).toMatchObject({
         firstValid: {
-          type: "ifNull",
+          type: "coalesce",
           args: [
             { type: "column", path: ["T1", "email"] },
             { type: "column", path: ["T1", "name"] },
@@ -243,7 +243,7 @@ describe("Expr - Conditional functions", () => {
 
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ifNullMultiple[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.coalesceMultiple[dialect]);
     });
   });
 });

package/tests/expr/date.spec.ts

@@ -121,7 +121,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         daysDiff: {
           type: "dateDiff",
-          separator: "day",
+          unit: "day",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -180,7 +180,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         hoursDiff: {
           type: "dateDiff",
-          separator: "hour",
+          unit: "hour",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -207,7 +207,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         minutesDiff: {
           type: "dateDiff",
-          separator: "minute",
+          unit: "minute",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -234,7 +234,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         secondsDiff: {
           type: "dateDiff",
-          separator: "second",
+          unit: "second",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -260,7 +260,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         nextMonth: {
           type: "dateAdd",
-          separator: "month",
+          unit: "month",
           source: { type: "column", path: ["T1", "createdAt"] },
           value: { type: "value", value: 1 },
         },

package/tests/select/basic.spec.ts

@@ -119,12 +119,12 @@ describe("SELECT - Basic", () => {
     });
   });
 
-  describe("ifNull (2 arguments)", () => {
+  describe("coalesce (2 arguments)", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        email: expr.ifNull(item.email, "N/A"),
+        email: expr.coalesce(item.email, "N/A"),
       }))
       .getSelectQueryDef();
 
@@ -135,7 +135,7 @@ describe("SELECT - Basic", () => {
         from: { database: "TestDb", schema: "TestSchema", name: "User" },
         select: {
           email: {
-            type: "ifNull",
+            type: "coalesce",
             args: [
               { type: "column", path: ["T1", "email"] },
               { type: "value", value: "N/A" },
@@ -151,12 +151,12 @@ describe("SELECT - Basic", () => {
     });
   });
 
-  describe("ifNull (3 arguments, COALESCE)", () => {
+  describe("coalesce (3 arguments, COALESCE)", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        contact: expr.ifNull(item.email, item.name, "N/A"),
+        contact: expr.coalesce(item.email, item.name, "N/A"),
       }))
       .getSelectQueryDef();
 

package/tests/utils/result-parser.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { bytesFromHex, DateOnly, DateTime, Time, Uuid } from "@simplysm/core-common";
+import { bytes, DateOnly, DateTime, Time, Uuid } from "@simplysm/core-common";
 import { parseQueryResult } from "../../src/utils/result-parser";
 import type { ResultMeta } from "../../src/types/db";
 
@@ -112,7 +112,7 @@ describe("result-parser", () => {
 
     it("Uuid conversion - Uint8Array", async () => {
       const uuidStr = "550e8400-e29b-41d4-a716-446655440000";
-      const uuidBytes = bytesFromHex(uuidStr.replace(/-/g, ""));
+      const uuidBytes = bytes.fromHex(uuidStr.replace(/-/g, ""));
       const raw = [{ id: uuidBytes }];
       const meta: ResultMeta = {
         columns: { id: "Uuid" },
@@ -126,8 +126,8 @@ describe("result-parser", () => {
     });
 
     it("Bytes conversion - Uint8Array passthrough", async () => {
-      const bytes = new Uint8Array([0x01, 0x02, 0x03]);
-      const raw = [{ data: bytes }];
+      const rawBytes = new Uint8Array([0x01, 0x02, 0x03]);
+      const raw = [{ data: rawBytes }];
       const meta: ResultMeta = {
         columns: { data: "Bytes" },
         joins: {},