{"ast":null,"code":"import { ProtoError, MisuseError } from \"./errors.js\";\nimport { stmtResultFromProto, rowsResultFromProto, rowResultFromProto, valueResultFromProto, errorFromProto } from \"./result.js\";\nimport { stmtToProto } from \"./stmt.js\";\nimport { impossible } from \"./util.js\";\n/** A builder for creating a batch and executing it on the server. */\nexport class Batch {\n  /** @private */\n  _stream;\n  #useCursor;\n  /** @private */\n  _steps;\n  #executed;\n  /** @private */\n  constructor(stream, useCursor) {\n    this._stream = stream;\n    this.#useCursor = useCursor;\n    this._steps = [];\n    this.#executed = false;\n  }\n  /** Return a builder for adding a step to the batch. */\n  step() {\n    return new BatchStep(this);\n  }\n  /** Execute the batch. */\n  execute() {\n    if (this.#executed) {\n      throw new MisuseError(\"This batch has already been executed\");\n    }\n    this.#executed = true;\n    const batch = {\n      steps: this._steps.map(step => step.proto)\n    };\n    if (this.#useCursor) {\n      return executeCursor(this._stream, this._steps, batch);\n    } else {\n      return executeRegular(this._stream, this._steps, batch);\n    }\n  }\n}\nfunction executeRegular(stream, steps, batch) {\n  return stream._batch(batch).then(result => {\n    for (let step = 0; step < steps.length; ++step) {\n      const stepResult = result.stepResults.get(step);\n      const stepError = result.stepErrors.get(step);\n      steps[step].callback(stepResult, stepError);\n    }\n  });\n}\nasync function executeCursor(stream, steps, batch) {\n  const cursor = await stream._openCursor(batch);\n  try {\n    let nextStep = 0;\n    let beginEntry = undefined;\n    let rows = [];\n    for (;;) {\n      const entry = await cursor.next();\n      if (entry === undefined) {\n        break;\n      }\n      if (entry.type === \"step_begin\") {\n        if (entry.step < nextStep || entry.step >= steps.length) {\n          throw new ProtoError(\"Server produced StepBeginEntry for unexpected step\");\n        } else if (beginEntry !== undefined) {\n          throw new ProtoError(\"Server produced StepBeginEntry before terminating previous step\");\n        }\n        for (let step = nextStep; step < entry.step; ++step) {\n          steps[step].callback(undefined, undefined);\n        }\n        nextStep = entry.step + 1;\n        beginEntry = entry;\n        rows = [];\n      } else if (entry.type === \"step_end\") {\n        if (beginEntry === undefined) {\n          throw new ProtoError(\"Server produced StepEndEntry but no step is active\");\n        }\n        const stmtResult = {\n          cols: beginEntry.cols,\n          rows,\n          affectedRowCount: entry.affectedRowCount,\n          lastInsertRowid: entry.lastInsertRowid\n        };\n        steps[beginEntry.step].callback(stmtResult, undefined);\n        beginEntry = undefined;\n        rows = [];\n      } else if (entry.type === \"step_error\") {\n        if (beginEntry === undefined) {\n          if (entry.step >= steps.length) {\n            throw new ProtoError(\"Server produced StepErrorEntry for unexpected step\");\n          }\n          for (let step = nextStep; step < entry.step; ++step) {\n            steps[step].callback(undefined, undefined);\n          }\n        } else {\n          if (entry.step !== beginEntry.step) {\n            throw new ProtoError(\"Server produced StepErrorEntry for unexpected step\");\n          }\n          beginEntry = undefined;\n          rows = [];\n        }\n        steps[entry.step].callback(undefined, entry.error);\n        nextStep = entry.step + 1;\n      } else if (entry.type === \"row\") {\n        if (beginEntry === undefined) {\n          throw new ProtoError(\"Server produced RowEntry but no step is active\");\n        }\n        rows.push(entry.row);\n      } else if (entry.type === \"error\") {\n        throw errorFromProto(entry.error);\n      } else if (entry.type === \"none\") {\n        throw new ProtoError(\"Server produced unrecognized CursorEntry\");\n      } else {\n        throw impossible(entry, \"Impossible CursorEntry\");\n      }\n    }\n    if (beginEntry !== undefined) {\n      throw new ProtoError(\"Server closed Cursor before terminating active step\");\n    }\n    for (let step = nextStep; step < steps.length; ++step) {\n      steps[step].callback(undefined, undefined);\n    }\n  } finally {\n    cursor.close();\n  }\n}\n/** A builder for adding a step to the batch. */\nexport class BatchStep {\n  /** @private */\n  _batch;\n  #conds;\n  /** @private */\n  _index;\n  /** @private */\n  constructor(batch) {\n    this._batch = batch;\n    this.#conds = [];\n    this._index = undefined;\n  }\n  /** Add the condition that needs to be satisfied to execute the statement. If you use this method multiple\n   * times, we join the conditions with a logical AND. */\n  condition(cond) {\n    this.#conds.push(cond._proto);\n    return this;\n  }\n  /** Add a statement that returns rows. */\n  query(stmt) {\n    return this.#add(stmt, true, rowsResultFromProto);\n  }\n  /** Add a statement that returns at most a single row. */\n  queryRow(stmt) {\n    return this.#add(stmt, true, rowResultFromProto);\n  }\n  /** Add a statement that returns at most a single value. */\n  queryValue(stmt) {\n    return this.#add(stmt, true, valueResultFromProto);\n  }\n  /** Add a statement without returning rows. */\n  run(stmt) {\n    return this.#add(stmt, false, stmtResultFromProto);\n  }\n  #add(inStmt, wantRows, fromProto) {\n    if (this._index !== undefined) {\n      throw new MisuseError(\"This BatchStep has already been added to the batch\");\n    }\n    const stmt = stmtToProto(this._batch._stream._sqlOwner(), inStmt, wantRows);\n    let condition;\n    if (this.#conds.length === 0) {\n      condition = undefined;\n    } else if (this.#conds.length === 1) {\n      condition = this.#conds[0];\n    } else {\n      condition = {\n        type: \"and\",\n        conds: this.#conds.slice()\n      };\n    }\n    const proto = {\n      stmt,\n      condition\n    };\n    return new Promise((outputCallback, errorCallback) => {\n      const callback = (stepResult, stepError) => {\n        if (stepResult !== undefined && stepError !== undefined) {\n          errorCallback(new ProtoError(\"Server returned both result and error\"));\n        } else if (stepError !== undefined) {\n          errorCallback(errorFromProto(stepError));\n        } else if (stepResult !== undefined) {\n          outputCallback(fromProto(stepResult, this._batch._stream.intMode));\n        } else {\n          outputCallback(undefined);\n        }\n      };\n      this._index = this._batch._steps.length;\n      this._batch._steps.push({\n        proto,\n        callback\n      });\n    });\n  }\n}\nexport class BatchCond {\n  /** @private */\n  _batch;\n  /** @private */\n  _proto;\n  /** @private */\n  constructor(batch, proto) {\n    this._batch = batch;\n    this._proto = proto;\n  }\n  /** Create a condition that evaluates to true when the given step executes successfully.\n   *\n   * If the given step fails error or is skipped because its condition evaluated to false, this\n   * condition evaluates to false.\n   */\n  static ok(step) {\n    return new BatchCond(step._batch, {\n      type: \"ok\",\n      step: stepIndex(step)\n    });\n  }\n  /** Create a condition that evaluates to true when the given step fails.\n   *\n   * If the given step succeeds or is skipped because its condition evaluated to false, this condition\n   * evaluates to false.\n   */\n  static error(step) {\n    return new BatchCond(step._batch, {\n      type: \"error\",\n      step: stepIndex(step)\n    });\n  }\n  /** Create a condition that is a logical negation of another condition.\n   */\n  static not(cond) {\n    return new BatchCond(cond._batch, {\n      type: \"not\",\n      cond: cond._proto\n    });\n  }\n  /** Create a condition that is a logical AND of other conditions.\n   */\n  static and(batch, conds) {\n    for (const cond of conds) {\n      checkCondBatch(batch, cond);\n    }\n    return new BatchCond(batch, {\n      type: \"and\",\n      conds: conds.map(e => e._proto)\n    });\n  }\n  /** Create a condition that is a logical OR of other conditions.\n   */\n  static or(batch, conds) {\n    for (const cond of conds) {\n      checkCondBatch(batch, cond);\n    }\n    return new BatchCond(batch, {\n      type: \"or\",\n      conds: conds.map(e => e._proto)\n    });\n  }\n  /** Create a condition that evaluates to true when the SQL connection is in autocommit mode (not inside an\n   * explicit transaction). This requires protocol version 3 or higher.\n   */\n  static isAutocommit(batch) {\n    batch._stream.client()._ensureVersion(3, \"BatchCond.isAutocommit()\");\n    return new BatchCond(batch, {\n      type: \"is_autocommit\"\n    });\n  }\n}\nfunction stepIndex(step) {\n  if (step._index === undefined) {\n    throw new MisuseError(\"Cannot add a condition referencing a step that has not been added to the batch\");\n  }\n  return step._index;\n}\nfunction checkCondBatch(expectedBatch, cond) {\n  if (cond._batch !== expectedBatch) {\n    throw new MisuseError(\"Cannot mix BatchCond objects for different Batch objects\");\n  }\n}","map":{"version":3,"names":["ProtoError","MisuseError","stmtResultFromProto","rowsResultFromProto","rowResultFromProto","valueResultFromProto","errorFromProto","stmtToProto","impossible","Batch","_stream","useCursor","_steps","executed","constructor","stream","step","BatchStep","execute","batch","steps","map","proto","executeCursor","executeRegular","_batch","then","result","length","stepResult","stepResults","get","stepError","stepErrors","callback","cursor","_openCursor","nextStep","beginEntry","undefined","rows","entry","next","type","stmtResult","cols","affectedRowCount","lastInsertRowid","error","push","row","close","conds","_index","condition","cond","_proto","query","stmt","add","queryRow","queryValue","run","#add","inStmt","wantRows","fromProto","_sqlOwner","slice","Promise","outputCallback","errorCallback","intMode","BatchCond","ok","stepIndex","not","and","checkCondBatch","e","or","isAutocommit","client","_ensureVersion","expectedBatch"],"sources":["/Users/shoofle/Projects/the-forest/node_modules/@libsql/hrana-client/lib-esm/batch.js"],"sourcesContent":["import { ProtoError, MisuseError } from \"./errors.js\";\nimport { stmtResultFromProto, rowsResultFromProto, rowResultFromProto, valueResultFromProto, errorFromProto, } from \"./result.js\";\nimport { stmtToProto } from \"./stmt.js\";\nimport { impossible } from \"./util.js\";\n/** A builder for creating a batch and executing it on the server. */\nexport class Batch {\n    /** @private */\n    _stream;\n    #useCursor;\n    /** @private */\n    _steps;\n    #executed;\n    /** @private */\n    constructor(stream, useCursor) {\n        this._stream = stream;\n        this.#useCursor = useCursor;\n        this._steps = [];\n        this.#executed = false;\n    }\n    /** Return a builder for adding a step to the batch. */\n    step() {\n        return new BatchStep(this);\n    }\n    /** Execute the batch. */\n    execute() {\n        if (this.#executed) {\n            throw new MisuseError(\"This batch has already been executed\");\n        }\n        this.#executed = true;\n        const batch = {\n            steps: this._steps.map((step) => step.proto),\n        };\n        if (this.#useCursor) {\n            return executeCursor(this._stream, this._steps, batch);\n        }\n        else {\n            return executeRegular(this._stream, this._steps, batch);\n        }\n    }\n}\nfunction executeRegular(stream, steps, batch) {\n    return stream._batch(batch).then((result) => {\n        for (let step = 0; step < steps.length; ++step) {\n            const stepResult = result.stepResults.get(step);\n            const stepError = result.stepErrors.get(step);\n            steps[step].callback(stepResult, stepError);\n        }\n    });\n}\nasync function executeCursor(stream, steps, batch) {\n    const cursor = await stream._openCursor(batch);\n    try {\n        let nextStep = 0;\n        let beginEntry = undefined;\n        let rows = [];\n        for (;;) {\n            const entry = await cursor.next();\n            if (entry === undefined) {\n                break;\n            }\n            if (entry.type === \"step_begin\") {\n                if (entry.step < nextStep || entry.step >= steps.length) {\n                    throw new ProtoError(\"Server produced StepBeginEntry for unexpected step\");\n                }\n                else if (beginEntry !== undefined) {\n                    throw new ProtoError(\"Server produced StepBeginEntry before terminating previous step\");\n                }\n                for (let step = nextStep; step < entry.step; ++step) {\n                    steps[step].callback(undefined, undefined);\n                }\n                nextStep = entry.step + 1;\n                beginEntry = entry;\n                rows = [];\n            }\n            else if (entry.type === \"step_end\") {\n                if (beginEntry === undefined) {\n                    throw new ProtoError(\"Server produced StepEndEntry but no step is active\");\n                }\n                const stmtResult = {\n                    cols: beginEntry.cols,\n                    rows,\n                    affectedRowCount: entry.affectedRowCount,\n                    lastInsertRowid: entry.lastInsertRowid,\n                };\n                steps[beginEntry.step].callback(stmtResult, undefined);\n                beginEntry = undefined;\n                rows = [];\n            }\n            else if (entry.type === \"step_error\") {\n                if (beginEntry === undefined) {\n                    if (entry.step >= steps.length) {\n                        throw new ProtoError(\"Server produced StepErrorEntry for unexpected step\");\n                    }\n                    for (let step = nextStep; step < entry.step; ++step) {\n                        steps[step].callback(undefined, undefined);\n                    }\n                }\n                else {\n                    if (entry.step !== beginEntry.step) {\n                        throw new ProtoError(\"Server produced StepErrorEntry for unexpected step\");\n                    }\n                    beginEntry = undefined;\n                    rows = [];\n                }\n                steps[entry.step].callback(undefined, entry.error);\n                nextStep = entry.step + 1;\n            }\n            else if (entry.type === \"row\") {\n                if (beginEntry === undefined) {\n                    throw new ProtoError(\"Server produced RowEntry but no step is active\");\n                }\n                rows.push(entry.row);\n            }\n            else if (entry.type === \"error\") {\n                throw errorFromProto(entry.error);\n            }\n            else if (entry.type === \"none\") {\n                throw new ProtoError(\"Server produced unrecognized CursorEntry\");\n            }\n            else {\n                throw impossible(entry, \"Impossible CursorEntry\");\n            }\n        }\n        if (beginEntry !== undefined) {\n            throw new ProtoError(\"Server closed Cursor before terminating active step\");\n        }\n        for (let step = nextStep; step < steps.length; ++step) {\n            steps[step].callback(undefined, undefined);\n        }\n    }\n    finally {\n        cursor.close();\n    }\n}\n/** A builder for adding a step to the batch. */\nexport class BatchStep {\n    /** @private */\n    _batch;\n    #conds;\n    /** @private */\n    _index;\n    /** @private */\n    constructor(batch) {\n        this._batch = batch;\n        this.#conds = [];\n        this._index = undefined;\n    }\n    /** Add the condition that needs to be satisfied to execute the statement. If you use this method multiple\n     * times, we join the conditions with a logical AND. */\n    condition(cond) {\n        this.#conds.push(cond._proto);\n        return this;\n    }\n    /** Add a statement that returns rows. */\n    query(stmt) {\n        return this.#add(stmt, true, rowsResultFromProto);\n    }\n    /** Add a statement that returns at most a single row. */\n    queryRow(stmt) {\n        return this.#add(stmt, true, rowResultFromProto);\n    }\n    /** Add a statement that returns at most a single value. */\n    queryValue(stmt) {\n        return this.#add(stmt, true, valueResultFromProto);\n    }\n    /** Add a statement without returning rows. */\n    run(stmt) {\n        return this.#add(stmt, false, stmtResultFromProto);\n    }\n    #add(inStmt, wantRows, fromProto) {\n        if (this._index !== undefined) {\n            throw new MisuseError(\"This BatchStep has already been added to the batch\");\n        }\n        const stmt = stmtToProto(this._batch._stream._sqlOwner(), inStmt, wantRows);\n        let condition;\n        if (this.#conds.length === 0) {\n            condition = undefined;\n        }\n        else if (this.#conds.length === 1) {\n            condition = this.#conds[0];\n        }\n        else {\n            condition = { type: \"and\", conds: this.#conds.slice() };\n        }\n        const proto = { stmt, condition };\n        return new Promise((outputCallback, errorCallback) => {\n            const callback = (stepResult, stepError) => {\n                if (stepResult !== undefined && stepError !== undefined) {\n                    errorCallback(new ProtoError(\"Server returned both result and error\"));\n                }\n                else if (stepError !== undefined) {\n                    errorCallback(errorFromProto(stepError));\n                }\n                else if (stepResult !== undefined) {\n                    outputCallback(fromProto(stepResult, this._batch._stream.intMode));\n                }\n                else {\n                    outputCallback(undefined);\n                }\n            };\n            this._index = this._batch._steps.length;\n            this._batch._steps.push({ proto, callback });\n        });\n    }\n}\nexport class BatchCond {\n    /** @private */\n    _batch;\n    /** @private */\n    _proto;\n    /** @private */\n    constructor(batch, proto) {\n        this._batch = batch;\n        this._proto = proto;\n    }\n    /** Create a condition that evaluates to true when the given step executes successfully.\n     *\n     * If the given step fails error or is skipped because its condition evaluated to false, this\n     * condition evaluates to false.\n     */\n    static ok(step) {\n        return new BatchCond(step._batch, { type: \"ok\", step: stepIndex(step) });\n    }\n    /** Create a condition that evaluates to true when the given step fails.\n     *\n     * If the given step succeeds or is skipped because its condition evaluated to false, this condition\n     * evaluates to false.\n     */\n    static error(step) {\n        return new BatchCond(step._batch, { type: \"error\", step: stepIndex(step) });\n    }\n    /** Create a condition that is a logical negation of another condition.\n     */\n    static not(cond) {\n        return new BatchCond(cond._batch, { type: \"not\", cond: cond._proto });\n    }\n    /** Create a condition that is a logical AND of other conditions.\n     */\n    static and(batch, conds) {\n        for (const cond of conds) {\n            checkCondBatch(batch, cond);\n        }\n        return new BatchCond(batch, { type: \"and\", conds: conds.map(e => e._proto) });\n    }\n    /** Create a condition that is a logical OR of other conditions.\n     */\n    static or(batch, conds) {\n        for (const cond of conds) {\n            checkCondBatch(batch, cond);\n        }\n        return new BatchCond(batch, { type: \"or\", conds: conds.map(e => e._proto) });\n    }\n    /** Create a condition that evaluates to true when the SQL connection is in autocommit mode (not inside an\n     * explicit transaction). This requires protocol version 3 or higher.\n     */\n    static isAutocommit(batch) {\n        batch._stream.client()._ensureVersion(3, \"BatchCond.isAutocommit()\");\n        return new BatchCond(batch, { type: \"is_autocommit\" });\n    }\n}\nfunction stepIndex(step) {\n    if (step._index === undefined) {\n        throw new MisuseError(\"Cannot add a condition referencing a step that has not been added to the batch\");\n    }\n    return step._index;\n}\nfunction checkCondBatch(expectedBatch, cond) {\n    if (cond._batch !== expectedBatch) {\n        throw new MisuseError(\"Cannot mix BatchCond objects for different Batch objects\");\n    }\n}\n"],"mappings":"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","ignoreList":[]},"metadata":{},"sourceType":"module","externalDependencies":[]}