@noormdev/sdk 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/index.d.ts

@@ -3920,6 +3920,57 @@ export declare class Context<DB = unknown, Procs = object, Funcs = object, Tvfs
 	impersonate<T>(username: string, fn: (scope: ImpersonatedScope<DB, Procs, Funcs, Tvfs>) => Promise<T>): Promise<T>;
 	impersonate(username: string): Promise<ImpersonatedScope<DB, Procs, Funcs, Tvfs>>;
 }
+/**
+ * A TVP marker that wraps row data with the required table type name.
+ *
+ * Use the `tvp()` helper to create instances. Column names are
+ * inferred from the object keys of the first row.
+ *
+ * @example
+ * ```typescript
+ * interface CheckoutItem { Type: string; ReferenceNo: number; Qty: number }
+ *
+ * interface MyProcs {
+ *     'Checkout_trx': [{ Party: number; Items: TvpValue<CheckoutItem> }, void];
+ * }
+ * ```
+ */
+export interface TvpValue<T extends Record<string, unknown> = Record<string, unknown>> {
+	readonly __noorm_tvp: true;
+	readonly typeName: string;
+	readonly rows: ReadonlyArray<T>;
+}
+/**
+ * Create a Table-Valued Parameter for MSSQL stored procedure calls.
+ *
+ * Wraps an array of row objects as a TVP with the specified SQL Server
+ * table type name. Column names are inferred from the first row's keys.
+ *
+ * @param typeName - SQL Server table type (e.g., 'CheckoutItems' or 'dbo.CheckoutItems')
+ * @param rows - Array of row objects with consistent keys
+ *
+ * @example
+ * ```typescript
+ * interface CheckoutItem { Type: number; ReferenceNo: number; Qty: number }
+ *
+ * // Row type is inferred — returns TvpValue<CheckoutItem>
+ * const items: CheckoutItem[] = [
+ *     { Type: 1, ReferenceNo: 100, Qty: 5 },
+ *     { Type: 2, ReferenceNo: 200, Qty: 3 },
+ * ];
+ *
+ * // Named params — type-checked against TvpValue<CheckoutItem>
+ * await ctx.proc('Checkout_trx', {
+ *     Party: 1,
+ *     PaymentMethod: 2,
+ *     Items: tvp('CheckoutItems', items),
+ * });
+ *
+ * // Positional params
+ * await ctx.proc('Checkout_trx', [1, 2, tvp('CheckoutItems', items)]);
+ * ```
+ */
+export declare function tvp<T extends Record<string, unknown>>(typeName: string, rows: T[]): TvpValue<T>;
 /**
  * Error thrown when requireTest is enabled but config.isTest is false.
  *

package/dist/index.js

@@ -16781,10 +16781,45 @@ async function waitForIdentityToLoad(db, dialect) {
     context: { identity }
   });
 }
+
+// src/sdk/tvp.ts
+var MSSQL_PARAM_LIMIT = 2100;
+function tvp(typeName, rows) {
+  if (!typeName) {
+    throw new Error("TVP type name is required.");
+  }
+  if (!Array.isArray(rows)) {
+    throw new Error("TVP rows must be an array.");
+  }
+  if (rows.length > 1) {
+    const expectedKeys = Object.keys(rows[0]).sort().join(",");
+    for (let i = 1; i < rows.length; i++) {
+      const rowKeys = Object.keys(rows[i]).sort().join(",");
+      if (rowKeys !== expectedKeys) {
+        throw new Error(
+          `TVP row ${i} has mismatched keys. Expected [${Object.keys(rows[0]).join(", ")}] but got [${Object.keys(rows[i]).join(", ")}].`
+        );
+      }
+    }
+  }
+  return {
+    __noorm_tvp: true,
+    typeName,
+    rows
+  };
+}
+function isTvp(value) {
+  return typeof value === "object" && value !== null && "__noorm_tvp" in value && value["__noorm_tvp"] === true;
+}
+
+// src/sdk/sql.ts
 function buildProcCall(dialect, name, params) {
   if (dialect === "sqlite") {
     throw new Error("SQLite does not support stored procedures.");
   }
+  if (params && hasTvpParam(params) && dialect !== "mssql") {
+    throw new Error("Table-valued parameters (TVP) are only supported on MSSQL.");
+  }
   const rawName = sql.raw(name);
   if (!params || Array.isArray(params) && params.length === 0 || !Array.isArray(params) && Object.keys(params).length === 0) {
     if (dialect === "mssql") {
@@ -16804,11 +16839,17 @@ function buildFuncCall(dialect, name, column, params) {
   if (dialect === "sqlite") {
     throw new Error("SQLite does not support database function calls.");
   }
+  if (params && hasTvpParam(params) && dialect !== "mssql") {
+    throw new Error("Table-valued parameters (TVP) are only supported on MSSQL.");
+  }
   const rawName = sql.raw(name);
   const rawCol = sql.raw(column);
   if (!params || Array.isArray(params) && params.length === 0 || !Array.isArray(params) && Object.keys(params).length === 0) {
     return sql`SELECT ${rawName}() AS ${rawCol}`;
   }
+  if (dialect === "mssql" && hasTvpParam(params)) {
+    return buildMssqlFuncWithTvp(rawName, rawCol, params);
+  }
   if (dialect === "postgres" && !Array.isArray(params)) {
     const parts = Object.entries(params).map(
       ([key, val]) => sql`${sql.raw(key)} => ${val}`
@@ -16835,10 +16876,16 @@ function buildTvfCall(dialect, name, params) {
   if (dialect === "mysql") {
     throw new Error("MySQL does not support table-valued functions.");
   }
+  if (params && hasTvpParam(params) && dialect !== "mssql") {
+    throw new Error("Table-valued parameters (TVP) are only supported on MSSQL.");
+  }
   const rawName = sql.raw(name);
   if (!params || Array.isArray(params) && params.length === 0 || !Array.isArray(params) && Object.keys(params).length === 0) {
     return sql`SELECT * FROM ${rawName}()`;
   }
+  if (dialect === "mssql" && hasTvpParam(params)) {
+    return buildMssqlTvfWithTvp(rawName, params);
+  }
   if (dialect === "postgres" && !Array.isArray(params)) {
     const parts = Object.entries(params).map(
       ([key, val]) => sql`${sql.raw(key)} => ${val}`
@@ -16850,6 +16897,9 @@ function buildTvfCall(dialect, name, params) {
   return sql`SELECT * FROM ${rawName}(${joined})`;
 }
 function buildMssqlProc(rawName, params) {
+  if (hasTvpParam(params)) {
+    return buildMssqlProcWithTvp(rawName, params);
+  }
   if (Array.isArray(params)) {
     const joined = sql.join(params.map((v) => sql`${v}`));
     return sql`EXEC ${rawName} ${joined}`;
@@ -16874,6 +16924,137 @@ function buildMysqlProc(rawName, params) {
   const joined = sql.join(values.map((v) => sql`${v}`));
   return sql`CALL ${rawName}(${joined})`;
 }
+function hasTvpParam(params) {
+  const values = Array.isArray(params) ? params : Object.values(params);
+  return values.some(isTvp);
+}
+function validateTvpParamCount(params) {
+  const values = Array.isArray(params) ? params : Object.values(params);
+  let count = 0;
+  for (const val of values) {
+    if (isTvp(val)) {
+      if (val.rows.length > 0) {
+        count += val.rows.length * Object.keys(val.rows[0]).length;
+      }
+    } else {
+      count += 1;
+    }
+  }
+  if (count > MSSQL_PARAM_LIMIT) {
+    throw new Error(
+      "TVP parameter count (" + count + ") exceeds MSSQL limit of " + MSSQL_PARAM_LIMIT + ". Split your TVP rows into smaller batches and call the procedure multiple times."
+    );
+  }
+}
+function buildMssqlProcWithTvp(rawName, params) {
+  validateTvpParamCount(params);
+  const preamble = [];
+  const execParts = [];
+  if (Array.isArray(params)) {
+    for (let i = 0; i < params.length; i++) {
+      const val = params[i];
+      if (isTvp(val)) {
+        const varName = `@__tvp_${i}`;
+        appendTvpStatements(preamble, varName, val);
+        execParts.push(sql.raw(varName));
+      } else {
+        execParts.push(sql`${val}`);
+      }
+    }
+  } else {
+    for (const [key, val] of Object.entries(params)) {
+      if (isTvp(val)) {
+        const varName = `@__tvp_${key}`;
+        appendTvpStatements(preamble, varName, val);
+        execParts.push(sql`${sql.raw(`@${key}`)} = ${sql.raw(varName)}`);
+      } else {
+        execParts.push(sql`${sql.raw(`@${key}`)} = ${val}`);
+      }
+    }
+  }
+  const execStmt = sql`EXEC ${rawName} ${sql.join(execParts)}`;
+  if (preamble.length === 0) {
+    return execStmt;
+  }
+  return sql.join([...preamble, execStmt], sql.raw("; "));
+}
+function appendTvpStatements(statements, varName, tvpVal) {
+  statements.push(sql.raw(`DECLARE ${varName} ${tvpVal.typeName}`));
+  if (tvpVal.rows.length === 0) return;
+  const cols = Object.keys(tvpVal.rows[0]);
+  const colList = cols.map((c) => `[${c}]`).join(", ");
+  const rowFragments = tvpVal.rows.map((row) => {
+    const values = cols.map((c) => sql`${row[c]}`);
+    return sql`(${sql.join(values)})`;
+  });
+  statements.push(
+    sql`INSERT INTO ${sql.raw(varName)} (${sql.raw(colList)}) VALUES ${sql.join(rowFragments)}`
+  );
+}
+function buildMssqlFuncWithTvp(rawName, rawCol, params) {
+  validateTvpParamCount(params);
+  const preamble = [];
+  const execParts = [];
+  if (Array.isArray(params)) {
+    for (let i = 0; i < params.length; i++) {
+      const val = params[i];
+      if (isTvp(val)) {
+        const varName = `@__tvp_${i}`;
+        appendTvpStatements(preamble, varName, val);
+        execParts.push(sql.raw(varName));
+      } else {
+        execParts.push(sql`${val}`);
+      }
+    }
+  } else {
+    for (const [key, val] of Object.entries(params)) {
+      if (isTvp(val)) {
+        const varName = `@__tvp_${key}`;
+        appendTvpStatements(preamble, varName, val);
+        execParts.push(sql`${sql.raw(`@${key}`)} = ${sql.raw(varName)}`);
+      } else {
+        execParts.push(sql`${sql.raw(`@${key}`)} = ${val}`);
+      }
+    }
+  }
+  const funcStmt = sql`DECLARE @__result sql_variant; EXEC @__result = ${rawName} ${sql.join(execParts)}; SELECT @__result AS ${rawCol}`;
+  if (preamble.length === 0) {
+    return funcStmt;
+  }
+  return sql.join([...preamble, funcStmt], sql.raw("; "));
+}
+function buildMssqlTvfWithTvp(rawName, params) {
+  validateTvpParamCount(params);
+  const preamble = [];
+  const callParts = [];
+  if (Array.isArray(params)) {
+    for (let i = 0; i < params.length; i++) {
+      const val = params[i];
+      if (isTvp(val)) {
+        const varName = `@__tvp_${i}`;
+        appendTvpStatements(preamble, varName, val);
+        callParts.push(sql.raw(varName));
+      } else {
+        callParts.push(sql`${val}`);
+      }
+    }
+  } else {
+    for (const [key, val] of Object.entries(params)) {
+      if (isTvp(val)) {
+        const varName = `@__tvp_${key}`;
+        appendTvpStatements(preamble, varName, val);
+        callParts.push(sql.raw(varName));
+      } else {
+        callParts.push(sql`${val}`);
+      }
+    }
+  }
+  const selectStmt = sql`SELECT * FROM ${rawName}(${sql.join(callParts)})`;
+  if (preamble.length === 0) {
+    return selectStmt;
+  }
+  return sql.join([...preamble, selectStmt], sql.raw("; "));
+}
 var ChangeValidationError = class extends Error {
   constructor(changeName, issue2) {
     super(`Invalid change '${changeName}': ${issue2}`);
@@ -23351,8 +23532,14 @@ async function teardownSchema(db, dialect, options = {}) {
       statements.push(ops.dropProcedure(proc.name, proc.schema));
     }
   }
-  if (!options.keepTypes) {
-    for (const type of types) {
+  const skipTypesDueToKeptRoutines = dialect === "mssql" && (options.keepFunctions || options.keepProcedures);
+  if (!options.keepTypes && !skipTypesDueToKeptRoutines) {
+    const sortedTypes = [...types].sort((a, b) => {
+      if (a.kind === "composite" && b.kind !== "composite") return -1;
+      if (a.kind !== "composite" && b.kind === "composite") return 1;
+      return 0;
+    });
+    for (const type of sortedTypes) {
       dropped.types.push(type.name);
       statements.push(ops.dropType(type.name, type.schema));
     }
@@ -27528,6 +27715,6 @@ async function createContext(options = {}) {
   return new Context(config2, settings, identity, options, projectRoot);
 }
 
-export { ChangeAlreadyAppliedError, ChangeNotAppliedError, ChangeNotFoundError, ChangeOrphanedError, ChangeValidationError, ChangesNamespace, Context, DbNamespace, DtNamespace, ImpersonationError, LockAcquireError, LockExpiredError, LockNamespace, ManifestReferenceError, NoormOps, ProtectedConfigError, RequireTestError, RunNamespace, SecretsNamespace, TemplatesNamespace, TransferNamespace, UtilsNamespace, VaultNamespace, createContext };
+export { ChangeAlreadyAppliedError, ChangeNotAppliedError, ChangeNotFoundError, ChangeOrphanedError, ChangeValidationError, ChangesNamespace, Context, DbNamespace, DtNamespace, ImpersonationError, LockAcquireError, LockExpiredError, LockNamespace, ManifestReferenceError, NoormOps, ProtectedConfigError, RequireTestError, RunNamespace, SecretsNamespace, TemplatesNamespace, TransferNamespace, UtilsNamespace, VaultNamespace, createContext, tvp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map