@noormdev/sdk 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/index.d.ts

@@ -1971,6 +1971,38 @@ export interface ImportOptions {
 	/** Truncate target table before import. Default: false. */
 	truncate?: boolean;
 }
+/**
+ * Extract the args type from a proc/func/tvf entry.
+ *
+ * Supports tuple form `[Args, Return]` and plain `void`.
+ * Non-tuple entries pass through as-is for backward compat.
+ *
+ * @example
+ * ```typescript
+ * ExtractArgs<[{ id: number }, User]>  // { id: number }
+ * ExtractArgs<void>                    // void
+ * ```
+ */
+export type ExtractArgs<E> = E extends [
+	infer A,
+	unknown
+] ? A : E;
+/**
+ * Extract the return type from a proc/func/tvf entry.
+ *
+ * Returns the second element of a `[Args, Return]` tuple.
+ * Falls back to `unknown` for `void` or non-tuple entries.
+ *
+ * @example
+ * ```typescript
+ * ExtractReturn<[{ id: number }, User]>  // User
+ * ExtractReturn<void>                    // unknown
+ * ```
+ */
+export type ExtractReturn<E> = E extends [
+	unknown,
+	infer R
+] ? R : unknown;
 export interface ContextState {
 	connection: ConnectionResult | null;
 	config: Config;
@@ -3698,19 +3730,19 @@ export declare class NoormOps {
  */
 export interface ImpersonatedScope<DB = unknown, Procs = object, Funcs = object, Tvfs = object> {
 	kysely: Kysely<DB>;
-	proc: <T = unknown, N extends keyof Procs & string = keyof Procs & string>(name: N, ...args: Procs[N] extends void ? [
+	proc: <N extends keyof Procs & string = keyof Procs & string, T = ExtractReturn<Procs[N]>>(name: N, ...args: ExtractArgs<Procs[N]> extends void ? [
 	] : [
-		params: Procs[N]
+		params: ExtractArgs<Procs[N]>
 	]) => Promise<T[]>;
-	func: <T = unknown, N extends keyof Funcs & string = keyof Funcs & string>(name: N, ...args: Funcs[N] extends void ? [
+	func: <N extends keyof Funcs & string = keyof Funcs & string, T = ExtractReturn<Funcs[N]>>(name: N, ...args: ExtractArgs<Funcs[N]> extends void ? [
 		column: string
 	] : [
-		params: Funcs[N],
+		params: ExtractArgs<Funcs[N]>,
 		column: string
 	]) => Promise<T>;
-	tvf: <T = unknown, N extends keyof Tvfs & string = keyof Tvfs & string>(name: N, ...args: Tvfs[N] extends void ? [
+	tvf: <N extends keyof Tvfs & string = keyof Tvfs & string, T = ExtractReturn<Tvfs[N]>>(name: N, ...args: ExtractArgs<Tvfs[N]> extends void ? [
 	] : [
-		params: Tvfs[N]
+		params: ExtractArgs<Tvfs[N]>
 	]) => Promise<T[]>;
 	transaction: <T>(fn: (trx: Transaction<DB>) => Promise<T>) => Promise<T>;
 	revert: () => Promise<void>;
@@ -3801,8 +3833,11 @@ export declare class Context<DB = unknown, Procs = object, Funcs = object, Tvfs
 	 *
 	 * @example
 	 * ```typescript
-	 * // Named params
-	 * const users = await ctx.proc<User>('get_users', { department_id: 1 });
+	 * // Return type inferred from tuple definition
+	 * const users = await ctx.proc('get_users', { department_id: 1 });
+	 *
+	 * // Explicit return type override
+	 * const users = await ctx.proc<'get_users', SpecialUser>('get_users', { department_id: 1 });
 	 *
 	 * // Positional params
 	 * await ctx.proc('simple_proc', [42, 'hello']);
@@ -3811,9 +3846,9 @@ export declare class Context<DB = unknown, Procs = object, Funcs = object, Tvfs
 	 * await ctx.proc('refresh_cache');
 	 * ```
 	 */
-	proc<T = unknown, N extends keyof Procs & string = keyof Procs & string>(name: N, ...args: Procs[N] extends void ? [
+	proc<N extends keyof Procs & string = keyof Procs & string, T = ExtractReturn<Procs[N]>>(name: N, ...args: ExtractArgs<Procs[N]> extends void ? [
 	] : [
-		params: Procs[N]
+		params: ExtractArgs<Procs[N]>
 	]): Promise<T[]>;
 	/**
 	 * Call a database function and return the scalar result.
@@ -3823,20 +3858,20 @@ export declare class Context<DB = unknown, Procs = object, Funcs = object, Tvfs
 	 *
 	 * @example
 	 * ```typescript
-	 * // Named params + column alias
-	 * const result = await ctx.func<{ total: number }>('calc_total', { order_id: 42 }, 'total');
+	 * // Return type inferred from tuple definition
+	 * const result = await ctx.func('calc_total', { order_id: 42 }, 'total');
 	 *
-	 * // Positional params + column alias
-	 * const sum = await ctx.func<{ result: number }>('add_numbers', [1, 2], 'result');
+	 * // Explicit return type override
+	 * const result = await ctx.func<'calc_total', { total: number }>('calc_total', { order_id: 42 }, 'total');
 	 *
 	 * // No params — just column alias
-	 * const ver = await ctx.func<{ v: string }>('get_version', 'v');
+	 * const ver = await ctx.func('get_version', 'v');
 	 * ```
 	 */
-	func<T = unknown, N extends keyof Funcs & string = keyof Funcs & string>(name: N, ...args: Funcs[N] extends void ? [
+	func<N extends keyof Funcs & string = keyof Funcs & string, T = ExtractReturn<Funcs[N]>>(name: N, ...args: ExtractArgs<Funcs[N]> extends void ? [
 		column: string
 	] : [
-		params: Funcs[N],
+		params: ExtractArgs<Funcs[N]>,
 		column: string
 	]): Promise<T>;
 	/**
@@ -3848,19 +3883,19 @@ export declare class Context<DB = unknown, Procs = object, Funcs = object, Tvfs
 	 *
 	 * @example
 	 * ```typescript
-	 * // Named params
-	 * const sessions = await ctx.tvf<Session>('validate_session', { session_key: key });
+	 * // Return type inferred from tuple definition
+	 * const sessions = await ctx.tvf('validate_session', { session_key: key });
 	 *
-	 * // Positional params
-	 * const results = await ctx.tvf<Result>('search_products', ['widget', 100]);
+	 * // Explicit return type override
+	 * const sessions = await ctx.tvf<'validate_session', SpecialSession>('validate_session', { session_key: key });
 	 *
 	 * // No params
-	 * const items = await ctx.tvf<Item>('get_active_items');
+	 * const items = await ctx.tvf('get_active_items');
 	 * ```
 	 */
-	tvf<T = unknown, N extends keyof Tvfs & string = keyof Tvfs & string>(name: N, ...args: Tvfs[N] extends void ? [
+	tvf<N extends keyof Tvfs & string = keyof Tvfs & string, T = ExtractReturn<Tvfs[N]>>(name: N, ...args: ExtractArgs<Tvfs[N]> extends void ? [
 	] : [
-		params: Tvfs[N]
+		params: ExtractArgs<Tvfs[N]>
 	]): Promise<T[]>;
 	/**
 	 * Execute queries as a specific database principal.
@@ -3885,6 +3920,50 @@ 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 MyProcs {
+ *     'Checkout_trx': [{ Party: number; PaymentMethod: number; Items: TvpValue }, void];
+ * }
+ * ```
+ */
+export interface TvpValue {
+	readonly __noorm_tvp: true;
+	readonly typeName: string;
+	readonly rows: ReadonlyArray<Record<string, unknown>>;
+}
+/**
+ * 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
+ * // Named params
+ * await ctx.proc('Checkout_trx', {
+ *     Party: 1,
+ *     PaymentMethod: 2,
+ *     Items: tvp('CheckoutItems', [
+ *         { Type: 1, ReferenceNo: 100, Qty: 5 },
+ *         { Type: 2, ReferenceNo: 200, Qty: 3 },
+ *     ]),
+ * });
+ *
+ * // Positional params
+ * await ctx.proc('Checkout_trx', [1, 2, tvp('CheckoutItems', items)]);
+ * ```
+ */
+export declare function tvp(typeName: string, rows: Record<string, unknown>[]): TvpValue;
 /**
  * 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}`);
@@ -23352,7 +23533,12 @@ async function teardownSchema(db, dialect, options = {}) {
     }
   }
   if (!options.keepTypes) {
-    for (const type of types) {
+    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));
     }
@@ -27364,8 +27550,11 @@ var Context = class {
    *
    * @example
    * ```typescript
-   * // Named params
-   * const users = await ctx.proc<User>('get_users', { department_id: 1 });
+   * // Return type inferred from tuple definition
+   * const users = await ctx.proc('get_users', { department_id: 1 });
+   *
+   * // Explicit return type override
+   * const users = await ctx.proc<'get_users', SpecialUser>('get_users', { department_id: 1 });
    *
    * // Positional params
    * await ctx.proc('simple_proc', [42, 'hello']);
@@ -27391,14 +27580,14 @@ var Context = class {
    *
    * @example
    * ```typescript
-   * // Named params + column alias
-   * const result = await ctx.func<{ total: number }>('calc_total', { order_id: 42 }, 'total');
+   * // Return type inferred from tuple definition
+   * const result = await ctx.func('calc_total', { order_id: 42 }, 'total');
    *
-   * // Positional params + column alias
-   * const sum = await ctx.func<{ result: number }>('add_numbers', [1, 2], 'result');
+   * // Explicit return type override
+   * const result = await ctx.func<'calc_total', { total: number }>('calc_total', { order_id: 42 }, 'total');
    *
    * // No params — just column alias
-   * const ver = await ctx.func<{ v: string }>('get_version', 'v');
+   * const ver = await ctx.func('get_version', 'v');
    * ```
    */
   async func(name, ...args) {
@@ -27424,14 +27613,14 @@ var Context = class {
    *
    * @example
    * ```typescript
-   * // Named params
-   * const sessions = await ctx.tvf<Session>('validate_session', { session_key: key });
+   * // Return type inferred from tuple definition
+   * const sessions = await ctx.tvf('validate_session', { session_key: key });
    *
-   * // Positional params
-   * const results = await ctx.tvf<Result>('search_products', ['widget', 100]);
+   * // Explicit return type override
+   * const sessions = await ctx.tvf<'validate_session', SpecialSession>('validate_session', { session_key: key });
    *
    * // No params
-   * const items = await ctx.tvf<Item>('get_active_items');
+   * const items = await ctx.tvf('get_active_items');
    * ```
    */
   async tvf(name, ...args) {
@@ -27525,6 +27714,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