@upstash/redis 1.36.1 → 1.37.0-rc.1

package/nodejs.js

@@ -21,7 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var nodejs_exports = {};
 __export(nodejs_exports, {
   Redis: () => Redis2,
-  errors: () => error_exports
+  errors: () => error_exports,
+  s: () => s
 });
 module.exports = __toCommonJS(nodejs_exports);
 
@@ -98,18 +99,8 @@ function mergeHeaders(...headers) {
   }
   return merged;
 }
-function kvArrayToObject(v) {
-  if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
-  if (!Array.isArray(v)) return {};
-  const obj = {};
-  for (let i = 0; i < v.length; i += 2) {
-    if (typeof v[i] === "string") obj[v[i]] = v[i + 1];
-  }
-  return obj;
-}
 
 // pkg/http.ts
-var MAX_BUFFER_SIZE = 1024 * 1024;
 var HttpClient = class {
   baseUrl;
   headers;
@@ -233,16 +224,11 @@ var HttpClient = class {
       const decoder = new TextDecoder();
       (async () => {
         try {
-          let buffer = "";
           while (true) {
             const { value, done } = await reader.read();
             if (done) break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            if (buffer.length > MAX_BUFFER_SIZE) {
-              throw new Error("Buffer size exceeded (1MB)");
-            }
+            const chunk = decoder.decode(value);
+            const lines = chunk.split("\n");
             for (const line of lines) {
               if (line.startsWith("data: ")) {
                 const data = line.slice(6);
@@ -360,7 +346,7 @@ var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
   "zrange",
   "exec"
 ]);
-function createAutoPipelineProxy(_redis, namespace = "root") {
+function createAutoPipelineProxy(_redis, json) {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -370,31 +356,29 @@ function createAutoPipelineProxy(_redis, namespace = "root") {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (namespace === "root" && command === "json") {
-        return createAutoPipelineProxy(redis2, "json");
-      }
-      if (namespace === "root" && command === "functions") {
-        return createAutoPipelineProxy(redis2, "functions");
+      if (command === "json") {
+        return createAutoPipelineProxy(redis2, true);
       }
-      if (namespace === "root") {
-        const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-        const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-        if (commandInRedisButNotPipeline || isCommandExcluded) {
-          return redis2[command];
-        }
+      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
+      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
+      if (commandInRedisButNotPipeline || isCommandExcluded) {
+        return redis2[command];
       }
-      const pipeline = redis2.autoPipelineExecutor.pipeline;
-      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
-      const isFunction = typeof targetFunction === "function";
+      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
       if (isFunction) {
         return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
-            const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
-            targetFunction2(...args);
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
+            if (json) {
+              pipeline.json[command](
+                ...args
+              );
+            } else {
+              pipeline[command](...args);
+            }
           });
         };
       }
-      return targetFunction;
+      return redis2.autoPipelineExecutor.pipeline[command];
     }
   });
 }
@@ -687,23 +671,6 @@ var ExpireAtCommand = class extends Command {
   }
 };
 
-// pkg/commands/fcall.ts
-var FCallCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(["fcall", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
-  }
-};
-
-// pkg/commands/fcall_ro.ts
-var FCallRoCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(
-      ["fcall_ro", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []],
-      opts
-    );
-  }
-};
-
 // pkg/commands/flushall.ts
 var FlushAllCommand = class extends Command {
   constructor(args, opts) {
@@ -726,85 +693,6 @@ var FlushDBCommand = class extends Command {
   }
 };
 
-// pkg/commands/function_delete.ts
-var FunctionDeleteCommand = class extends Command {
-  constructor([libraryName], opts) {
-    super(["function", "delete", libraryName], opts);
-  }
-};
-
-// pkg/commands/function_flush.ts
-var FunctionFlushCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "flush"], opts);
-  }
-};
-
-// pkg/commands/function_list.ts
-var FunctionListCommand = class extends Command {
-  constructor([args], opts) {
-    const command = ["function", "list"];
-    if (args?.libraryName) {
-      command.push("libraryname", args.libraryName);
-    }
-    if (args?.withCode) {
-      command.push("withcode");
-    }
-    super(command, { deserialize, ...opts });
-  }
-};
-function deserialize(result) {
-  if (!Array.isArray(result)) return [];
-  return result.map((libRaw) => {
-    const lib = kvArrayToObject(libRaw);
-    const functionsParsed = lib.functions.map(
-      (fnRaw) => kvArrayToObject(fnRaw)
-    );
-    return {
-      libraryName: lib.library_name,
-      engine: lib.engine,
-      functions: functionsParsed.map((fn) => ({
-        name: fn.name,
-        description: fn.description ?? void 0,
-        flags: fn.flags
-      })),
-      libraryCode: lib.library_code
-    };
-  });
-}
-
-// pkg/commands/function_load.ts
-var FunctionLoadCommand = class extends Command {
-  constructor([args], opts) {
-    super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
-  }
-};
-
-// pkg/commands/function_stats.ts
-var FunctionStatsCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "stats"], { deserialize: deserialize2, ...opts });
-  }
-};
-function deserialize2(result) {
-  const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
-  const parsedEngines = Object.fromEntries(
-    Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)])
-  );
-  const final = {
-    engines: Object.fromEntries(
-      Object.entries(parsedEngines).map(([key, value]) => [
-        key,
-        {
-          librariesCount: value.libraries_count,
-          functionsCount: value.functions_count
-        }
-      ])
-    )
-  };
-  return final;
-}
-
 // pkg/commands/geo_add.ts
 var GeoAddCommand = class extends Command {
   constructor([key, arg1, ...arg2], opts) {
@@ -1151,7 +1039,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize3(result) {
+function deserialize(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1171,7 +1059,7 @@ function deserialize3(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize3(result),
+      deserialize: (result) => deserialize(result),
       ...opts
     });
   }
@@ -1206,7 +1094,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize4(fields, result) {
+function deserialize2(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -1223,7 +1111,7 @@ function deserialize4(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize4(fields, result),
+      deserialize: (result) => deserialize2(fields, result),
       ...opts
     });
   }
@@ -1237,7 +1125,7 @@ var HMSetCommand = class extends Command {
 };
 
 // pkg/commands/hrandfield.ts
-function deserialize5(result) {
+function deserialize3(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1264,7 +1152,7 @@ var HRandFieldCommand = class extends Command {
     }
     super(command, {
       // @ts-expect-error to silence compiler
-      deserialize: cmd[2] ? (result) => deserialize5(result) : opts?.deserialize,
+      deserialize: cmd[2] ? (result) => deserialize3(result) : opts?.deserialize,
       ...opts
     });
   }
@@ -2234,7 +2122,7 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize6(result) {
+function deserialize4(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2263,7 +2151,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize6(result),
+      deserialize: (result) => deserialize4(result),
       ...opts
     });
   }
@@ -2326,12 +2214,12 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize7(result),
+      deserialize: (result) => deserialize5(result),
       ...opts
     });
   }
 };
-function deserialize7(result) {
+function deserialize5(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2601,6 +2489,265 @@ var ZUnionStoreCommand = class extends Command {
   }
 };
 
+// pkg/commands/search/types.ts
+var FIELD_TYPES = ["TEXT", "U64", "I64", "F64", "BOOL", "DATE"];
+
+// pkg/commands/search/utils.ts
+function isFieldType(value) {
+  return typeof value === "string" && FIELD_TYPES.includes(value);
+}
+function isDetailedField(value) {
+  return typeof value === "object" && value !== null && "type" in value && isFieldType(value.type);
+}
+function isNestedSchema(value) {
+  return typeof value === "object" && value !== null && !isDetailedField(value);
+}
+function flattenSchema(schema, pathPrefix = []) {
+  const fields = [];
+  for (const [key, value] of Object.entries(schema)) {
+    const currentPath = [...pathPrefix, key];
+    const pathString = currentPath.join(".");
+    if (isFieldType(value)) {
+      fields.push({
+        path: pathString,
+        type: value
+      });
+    } else if (isDetailedField(value)) {
+      fields.push({
+        path: pathString,
+        type: value.type,
+        fast: "fast" in value ? value.fast : void 0,
+        noTokenize: "noTokenize" in value ? value.noTokenize : void 0,
+        noStem: "noStem" in value ? value.noStem : void 0,
+        from: "from" in value ? value.from : void 0
+      });
+    } else if (isNestedSchema(value)) {
+      const nestedFields = flattenSchema(value, currentPath);
+      fields.push(...nestedFields);
+    }
+  }
+  return fields;
+}
+function deserializeQueryResponse(rawResponse) {
+  return rawResponse.map((itemRaw) => {
+    const raw = itemRaw;
+    const key = raw[0];
+    const score = raw[1];
+    const rawFields = raw[2];
+    if (rawFields === void 0) {
+      return { key, score };
+    }
+    if (!Array.isArray(rawFields) || rawFields.length === 0) {
+      return { key, score, data: {} };
+    }
+    let data = {};
+    for (const fieldRaw of rawFields) {
+      const key2 = fieldRaw[0];
+      const value = fieldRaw[1];
+      const pathParts = key2.split(".");
+      if (pathParts.length == 1) {
+        data[key2] = value;
+      } else {
+        let currentObj = data;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+          const pathPart = pathParts[i];
+          if (!(pathPart in currentObj)) {
+            currentObj[pathPart] = {};
+          }
+          currentObj = currentObj[pathPart];
+        }
+        currentObj[pathParts.at(-1)] = value;
+      }
+    }
+    if ("$" in data) {
+      data = data["$"];
+    }
+    return { key, score, data };
+  });
+}
+function deserializeDescribeResponse(rawResponse) {
+  const description = {};
+  for (let i = 0; i < rawResponse.length; i += 2) {
+    const descriptor = rawResponse[i];
+    switch (descriptor) {
+      case "name": {
+        description["name"] = rawResponse[i + 1];
+        break;
+      }
+      case "type": {
+        description["dataType"] = rawResponse[i + 1].toLowerCase();
+        break;
+      }
+      case "prefixes": {
+        description["prefixes"] = rawResponse[i + 1];
+        break;
+      }
+      case "language": {
+        description["language"] = rawResponse[i + 1];
+        break;
+      }
+      case "schema": {
+        const schema = {};
+        for (const fieldDescription of rawResponse[i + 1]) {
+          const fieldName = fieldDescription[0];
+          const fieldInfo = { type: fieldDescription[1] };
+          if (fieldDescription.length > 2) {
+            for (let j = 2; j < fieldDescription.length; j++) {
+              const fieldOption = fieldDescription[j];
+              switch (fieldOption) {
+                case "NOSTEM": {
+                  fieldInfo.noStem = true;
+                  break;
+                }
+                case "NOTOKENIZE": {
+                  fieldInfo.noTokenize = true;
+                  break;
+                }
+                case "FAST": {
+                  fieldInfo.fast = true;
+                  break;
+                }
+              }
+            }
+          }
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+  return description;
+}
+function parseCountResponse(rawResponse) {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+
+// pkg/commands/search/command-builder.ts
+function buildQueryCommand(redisCommand, name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const command = [redisCommand, name, query];
+  if (options?.limit !== void 0) {
+    command.push("LIMIT", options.limit.toString());
+  }
+  if (options?.offset !== void 0) {
+    command.push("OFFSET", options.offset.toString());
+  }
+  if (options?.select && Object.keys(options.select).length === 0) {
+    command.push("NOCONTENT");
+  }
+  if (options?.orderBy) {
+    command.push("ORDERBY");
+    for (const [field, direction] of Object.entries(options.orderBy)) {
+      command.push(field, direction);
+    }
+  }
+  if (options?.highlight) {
+    command.push(
+      "HIGHLIGHT",
+      "FIELDS",
+      options.highlight.fields.length.toString(),
+      ...options.highlight.fields
+    );
+    if (options.highlight.preTag && options.highlight.postTag) {
+      command.push("TAGS", options.highlight.preTag, options.highlight.postTag);
+    }
+  }
+  if (options?.select && Object.keys(options.select).length > 0) {
+    command.push(
+      "SELECT",
+      Object.keys(options.select).length.toString(),
+      ...Object.keys(options.select)
+    );
+  }
+  return command;
+}
+function buildCreateIndexCommand(params) {
+  const { name, schema, dataType, prefix, language, skipInitialScan, existsOk } = params;
+  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
+  const payload = [
+    name,
+    ...skipInitialScan ? ["SKIPINITIALSCAN"] : [],
+    ...existsOk ? ["EXISTSOK"] : [],
+    "ON",
+    dataType.toUpperCase(),
+    "PREFIX",
+    prefixArray.length.toString(),
+    ...prefixArray,
+    ...language ? ["LANGUAGE", language] : [],
+    "SCHEMA"
+  ];
+  const fields = flattenSchema(schema);
+  for (const field of fields) {
+    payload.push(field.path, field.type);
+    if (field.fast) {
+      payload.push("FAST");
+    }
+    if (field.noTokenize) {
+      payload.push("NOTOKENIZE");
+    }
+    if (field.noStem) {
+      payload.push("NOSTEM");
+    }
+    if (field.from) {
+      payload.push("FROM", field.from);
+    }
+  }
+  return ["SEARCH.CREATE", ...payload];
+}
+
+// pkg/commands/search/search.ts
+var SearchIndex = class {
+  name;
+  schema;
+  client;
+  constructor({ name, schema, client }) {
+    this.name = name;
+    this.schema = schema;
+    this.client = client;
+  }
+  async waitIndexing() {
+    const command = ["SEARCH.WAITINDEXING", this.name];
+    await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeQueryResponse(rawResult);
+  }
+  async count({ filter }) {
+    const command = buildQueryCommand("SEARCH.COUNT", this.name, { filter });
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return { count: parseCountResponse(rawResult) };
+  }
+  async drop() {
+    const command = ["SEARCH.DROP", this.name];
+    const result = await new ExecCommand(command).exec(this.client);
+    return result;
+  }
+};
+async function createIndex(client, params) {
+  const { name, schema } = params;
+  const createIndexCommand = buildCreateIndexCommand(params);
+  await new ExecCommand(createIndexCommand).exec(client);
+  return initIndex(client, { name, schema });
+}
+function initIndex(client, params) {
+  const { name, schema } = params;
+  return new SearchIndex({ name, schema, client });
+}
+
 // pkg/commands/psubscribe.ts
 var PSubscribeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -3626,38 +3773,6 @@ var Pipeline = class {
       type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       */
-      stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
-    };
-  }
 };
 
 // pkg/script.ts
@@ -3719,8 +3834,8 @@ var Script = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s) {
-    const data = new TextEncoder().encode(s);
+  async digest(s2) {
+    const data = new TextEncoder().encode(s2);
     const hashBuffer = await import_uncrypto.subtle.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -3783,8 +3898,8 @@ var ScriptRO = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s) {
-    const data = new TextEncoder().encode(s);
+  async digest(s2) {
+    const data = new TextEncoder().encode(s2);
     const hashBuffer = await import_uncrypto2.subtle.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -3919,40 +4034,6 @@ var Redis = class {
       type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       *
-       * Note: `running_script` field is not supported and therefore not included in the type.
-       */
-      stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
-    };
-  }
   /**
    * Wrap a new middleware around the HTTP client.
    */
@@ -4003,6 +4084,16 @@ var Redis = class {
   createScript(script, opts) {
     return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
+  get search() {
+    return {
+      createIndex: (params) => {
+        return createIndex(this.client, params);
+      },
+      index: (params) => {
+        return initIndex(this.client, params);
+      }
+    };
+  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4710,7 +4801,160 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.1";
+var VERSION = "v1.37.0-rc.1";
+
+// pkg/commands/search/schema-builder.ts
+var BUILD = Symbol("build");
+var TextFieldBuilder = class _TextFieldBuilder {
+  _noTokenize;
+  _noStem;
+  _from;
+  constructor(noTokenize = { noTokenize: false }, noStem = { noStem: false }, from = { from: null }) {
+    this._noTokenize = noTokenize;
+    this._noStem = noStem;
+    this._from = from;
+  }
+  noTokenize() {
+    return new _TextFieldBuilder({ noTokenize: true }, this._noStem, this._from);
+  }
+  noStem() {
+    return new _TextFieldBuilder(this._noTokenize, { noStem: true }, this._from);
+  }
+  from(field) {
+    return new _TextFieldBuilder(this._noTokenize, this._noStem, { from: field });
+  }
+  [BUILD]() {
+    const hasOptions = this._noTokenize.noTokenize || this._noStem.noStem || Boolean(this._from.from);
+    return hasOptions ? {
+      type: "TEXT",
+      ...this._noTokenize.noTokenize ? { noTokenize: true } : {},
+      ...this._noStem.noStem ? { noStem: true } : {},
+      ...this._from.from ? { from: this._from.from } : {}
+    } : "TEXT";
+  }
+};
+var NumericFieldBuilder = class _NumericFieldBuilder {
+  type;
+  _from;
+  constructor(type, from = { from: null }) {
+    this.type = type;
+    this._from = from;
+  }
+  from(field) {
+    return new _NumericFieldBuilder(this.type, { from: field });
+  }
+  [BUILD]() {
+    return this._from.from ? {
+      type: this.type,
+      fast: true,
+      from: this._from.from
+    } : {
+      type: this.type,
+      fast: true
+    };
+  }
+};
+var BoolFieldBuilder = class _BoolFieldBuilder {
+  _fast;
+  _from;
+  constructor(fast = { fast: false }, from = { from: null }) {
+    this._fast = fast;
+    this._from = from;
+  }
+  fast() {
+    return new _BoolFieldBuilder({ fast: true }, this._from);
+  }
+  from(field) {
+    return new _BoolFieldBuilder(this._fast, { from: field });
+  }
+  [BUILD]() {
+    const hasFast = this._fast.fast;
+    const hasFrom = Boolean(this._from.from);
+    if (hasFast && hasFrom) {
+      return {
+        type: "BOOL",
+        fast: true,
+        from: this._from.from
+      };
+    }
+    if (hasFast) {
+      return {
+        type: "BOOL",
+        fast: true
+      };
+    }
+    if (hasFrom) {
+      return {
+        type: "BOOL",
+        from: this._from.from
+      };
+    }
+    return "BOOL";
+  }
+};
+var DateFieldBuilder = class _DateFieldBuilder {
+  _fast;
+  _from;
+  constructor(fast = { fast: false }, from = { from: null }) {
+    this._fast = fast;
+    this._from = from;
+  }
+  fast() {
+    return new _DateFieldBuilder({ fast: true }, this._from);
+  }
+  from(field) {
+    return new _DateFieldBuilder(this._fast, { from: field });
+  }
+  [BUILD]() {
+    const hasFast = this._fast.fast;
+    const hasFrom = Boolean(this._from.from);
+    if (hasFast && hasFrom) {
+      return {
+        type: "DATE",
+        fast: true,
+        from: this._from.from
+      };
+    }
+    if (hasFast) {
+      return {
+        type: "DATE",
+        fast: true
+      };
+    }
+    if (hasFrom) {
+      return {
+        type: "DATE",
+        from: this._from.from
+      };
+    }
+    return "DATE";
+  }
+};
+var s = {
+  string() {
+    return new TextFieldBuilder();
+  },
+  number(type = "F64") {
+    return new NumericFieldBuilder(type);
+  },
+  boolean() {
+    return new BoolFieldBuilder();
+  },
+  date() {
+    return new DateFieldBuilder();
+  },
+  object(fields) {
+    const result = {};
+    for (const [key, value] of Object.entries(fields)) {
+      if (value && typeof value === "object" && BUILD in value) {
+        result[key] = value[BUILD]();
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
 
 // platforms/nodejs.ts
 if (typeof atob === "undefined") {
@@ -4768,20 +5012,18 @@ var Redis2 = class _Redis extends Redis {
       keepAlive: configOrRequester.keepAlive,
       readYourWrites: configOrRequester.readYourWrites
     });
-    const safeEnv = typeof process === "object" && process && typeof process.env === "object" && process.env ? process.env : {};
     super(client, {
       automaticDeserialization: configOrRequester.automaticDeserialization,
-      enableTelemetry: configOrRequester.enableTelemetry ?? !safeEnv.UPSTASH_DISABLE_TELEMETRY,
+      enableTelemetry: configOrRequester.enableTelemetry ?? !process.env.UPSTASH_DISABLE_TELEMETRY,
       latencyLogging: configOrRequester.latencyLogging,
       enableAutoPipelining: configOrRequester.enableAutoPipelining
     });
-    const nodeVersion = typeof process === "object" && process ? process.version : void 0;
     this.addTelemetry({
       runtime: (
         // @ts-expect-error to silence compiler
-        typeof EdgeRuntime === "string" ? "edge-light" : nodeVersion ? `node@${nodeVersion}` : "unknown"
+        typeof EdgeRuntime === "string" ? "edge-light" : `node@${process.version}`
       ),
-      platform: safeEnv.UPSTASH_CONSOLE ? "console" : safeEnv.VERCEL ? "vercel" : safeEnv.AWS_REGION ? "aws" : "unknown",
+      platform: process.env.UPSTASH_CONSOLE ? "console" : process.env.VERCEL ? "vercel" : process.env.AWS_REGION ? "aws" : "unknown",
       sdk: `@upstash/redis@${VERSION}`
     });
     if (this.enableAutoPipelining) {
@@ -4802,7 +5044,7 @@ var Redis2 = class _Redis extends Redis {
    * that may use different naming conventions.
    */
   static fromEnv(config) {
-    if (typeof process !== "object" || !process || typeof process.env !== "object" || !process.env) {
+    if (process.env === void 0) {
       throw new TypeError(
         '[Upstash Redis] Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please import from "@upstash/redis/cloudflare" instead'
       );
@@ -4823,5 +5065,6 @@ var Redis2 = class _Redis extends Redis {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Redis,
-  errors
+  errors,
+  s
 });