netsuite-soap 2025.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0286b70e48369bb6c048a18e9db11245df4e9304737f13a4674e2be392804507'
+  data.tar.gz: 24e3a94f0aef68c335788755dc1d1f4e61c2b3a6be3c96957acc382894b38344
+SHA512:
+  metadata.gz: 64b140f629ebccbcc92a50824a293d5507285d9bf9d230a41173173619c0165e16236beb535990552bd92bfc93c6e30e6a57ec3725f2276cf25750b105e0eb14
+  data.tar.gz: 9829b2c291d8b923195f7710f9ac9399150ced731c0f1c504b2a04eb83fff18b4b140bb40514b622fd753a9dcc8db7f29e8c41e7b2fc76f95b6f3c205e71a2bb

data/.envrc

@@ -0,0 +1,9 @@
+export BEADS_DIR="/Users/bobby/.local/share/git/bare/io.github/bdelanghe/.beads"
+
+# Prefer a repo-defined toolchain via Devbox (Nix). Falls back to rbenv if Devbox
+# isn't installed.
+if command -v devbox >/dev/null 2>&1; then
+  eval "$(devbox generate direnv --print-envrc)"
+elif command -v rbenv >/dev/null 2>&1; then
+  eval "$(rbenv init -)"
+fi

data/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [bdelanghe]

data/.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+
+  # Maintain dependencies for rubygems
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "daily"

data/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '32 15 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'ruby' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v6
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v4
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v4
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v4

data/.github/workflows/main.yml

@@ -0,0 +1,55 @@
+name: Ruby
+
+on: [push, pull_request]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.4']
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rspec
+        env:
+          COVERAGE: 'true'
+      - name: Read coverage
+        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+        id: coverage
+        run: |
+          if [ -f coverage/.last_run.json ]; then
+            LINE=$(jq '.result.line' coverage/.last_run.json)
+            echo "line=$LINE" >> $GITHUB_OUTPUT
+          fi
+      - name: Upload coverage badge
+        if: steps.coverage.outputs.line && github.ref == 'refs/heads/main' && github.event_name == 'push'
+        run: |
+          LINE=${{ steps.coverage.outputs.line }}
+          if [ $(echo "$LINE >= 90" | bc) -eq 1 ]; then COLOR="brightgreen"
+          elif [ $(echo "$LINE >= 80" | bc) -eq 1 ]; then COLOR="green"
+          elif [ $(echo "$LINE >= 70" | bc) -eq 1 ]; then COLOR="yellowgreen"
+          elif [ $(echo "$LINE >= 60" | bc) -eq 1 ]; then COLOR="yellow"
+          elif [ $(echo "$LINE >= 50" | bc) -eq 1 ]; then COLOR="orange"
+          else COLOR="red"; fi
+
+          mkdir -p /tmp/badges
+          echo "{\"schemaVersion\":1,\"label\":\"coverage\",\"message\":\"${LINE}%\",\"color\":\"${COLOR}\"}" > /tmp/badges/coverage.json
+
+          cd /tmp/badges
+          git init
+          git checkout --orphan badges
+          git add coverage.json
+          git -c user.name="github-actions[bot]" -c user.email="41898282+github-actions[bot]@users.noreply.github.com" \
+            commit -m "Update coverage badge: ${LINE}%"
+          git remote add origin "https://x-access-token:${{ github.token }}@github.com/${{ github.repository }}.git"
+          git push --force origin badges

data/.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: Publish Gem
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      id-token: write
+      attestations: write
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+
+      - name: Build gem
+        run: gem build netsuite.gemspec
+
+      - name: Attest build provenance
+        uses: actions/attest-build-provenance@v4
+        with:
+          subject-path: '*.gem'
+
+      - name: Publish to GitHub Packages
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:github: Bearer ${GH_TOKEN}\n" >> $HOME/.gem/credentials
+          gem push --key github --host https://rubygems.pkg.github.com/${OWNER} *.gem || echo "Already published to GitHub Packages, skipping."
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          OWNER: ${{ github.repository_owner }}
+
+      - name: Publish to RubyGems.org
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${RUBYGEMS_API_KEY}\n" >> $HOME/.gem/credentials
+          gem push *.gem || echo "Already published to RubyGems.org, skipping."
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.beads
+.devbox
+.env
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+devbox.lock
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/
+.tags*

data/.rspec

@@ -0,0 +1,6 @@
+--color
+--order rand
+--fail-fast
+--profile 10
+--warnings
+--format documentation

data/.ruby-version

@@ -0,0 +1 @@
+3.4.8

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.4.8

data/AGENTS.md

@@ -0,0 +1,150 @@
+# Project Instructions for AI Agents
+
+This file provides instructions and context for AI coding agents working on this project.
+
+<!-- BEGIN BEADS INTEGRATION -->
+## Issue Tracking with bd (beads)
+
+**IMPORTANT**: This project uses **bd (beads)** for ALL issue tracking. Do NOT use markdown TODOs, task lists, or other tracking methods.
+
+### Why bd?
+
+- Dependency-aware: Track blockers and relationships between issues
+- Git-friendly: Auto-syncs to JSONL for version control
+- Agent-optimized: JSON output, ready work detection, discovered-from links
+- Prevents duplicate tracking systems and confusion
+
+### Quick Start
+
+**Check for ready work:**
+
+```bash
+bd ready --json
+```
+
+**Create new issues:**
+
+```bash
+bd create "Issue title" --description="Detailed context" -t bug|feature|task -p 0-4 --json
+bd create "Issue title" --description="What this issue is about" -p 1 --deps discovered-from:bd-123 --json
+```
+
+**Claim and update:**
+
+```bash
+bd update bd-42 --status in_progress --json
+bd update bd-42 --priority 1 --json
+```
+
+**Complete work:**
+
+```bash
+bd close bd-42 --reason "Completed" --json
+```
+
+### Issue Types
+
+- `bug` - Something broken
+- `feature` - New functionality
+- `task` - Work item (tests, docs, refactoring)
+- `epic` - Large feature with subtasks
+- `chore` - Maintenance (dependencies, tooling)
+
+### Priorities
+
+- `0` - Critical (security, data loss, broken builds)
+- `1` - High (major features, important bugs)
+- `2` - Medium (default, nice-to-have)
+- `3` - Low (polish, optimization)
+- `4` - Backlog (future ideas)
+
+### Workflow for AI Agents
+
+1. **Check ready work**: `bd ready` shows unblocked issues
+2. **Claim your task**: `bd update <id> --status in_progress`
+3. **Work on it**: Implement, test, document
+4. **Discover new work?** Create linked issue:
+   - `bd create "Found bug" --description="Details about what was found" -p 1 --deps discovered-from:<parent-id>`
+5. **Complete**: `bd close <id> --reason "Done"`
+
+### Auto-Sync
+
+bd automatically syncs with git:
+
+- Exports to `.beads/issues.jsonl` after changes (5s debounce)
+- Imports from JSONL when newer (e.g., after `git pull`)
+- No manual export/import needed!
+
+### Important Rules
+
+- ✅ Use bd for ALL task tracking
+- ✅ Always use `--json` flag for programmatic use
+- ✅ Link discovered work with `discovered-from` dependencies
+- ✅ Check `bd ready` before asking "what should I work on?"
+- ❌ Do NOT create markdown TODO lists
+- ❌ Do NOT use external issue trackers
+- ❌ Do NOT duplicate tracking systems
+
+For more details, see README.md and docs/QUICKSTART.md.
+
+### Operational Rules for AI Agents
+
+- ✅ Do NOT use `bd edit` (interactive editor). Use `bd update` flags instead.
+- ✅ After making any bd changes, run `bd sync` to flush JSONL and git.
+- ✅ For manual bd testing, use an isolated DB: `BEADS_DB=/tmp/test.db`.
+- ✅ When committing work for an issue, include the issue ID in the commit message, e.g. `Fix flaky spec (bd-123)`.
+
+### Troubleshooting and Debugging
+
+- ✅ Enable debug logs with env vars when diagnosing issues:
+- `BD_DEBUG` (general), `BD_DEBUG_RPC` (daemon RPC), `BD_DEBUG_SYNC` (sync/import), `BD_DEBUG_FRESHNESS` (db file replacement, daemon logs).
+- ✅ Capture debug output to a file when needed: `BD_DEBUG=1 bd sync 2> debug.log`.
+- ✅ Daemon logs live in `.beads/daemon.log` (use `tail -f .beads/daemon.log`).
+- ✅ In sandboxed environments, use `bd --sandbox` to avoid daemon/staleness issues; run `bd sync` after leaving sandbox.
+
+### Architecture (Quick Understanding)
+
+- ✅ Three-layer model: CLI → local SQLite (`.beads/beads.db`) → git-tracked JSONL (`.beads/issues.jsonl`) → remote git.
+- ✅ SQLite is fast local cache; JSONL is the source of truth shared via git.
+- ✅ Daemon batches writes (default 5s debounce) and manages auto-export/import.
+- ✅ Hash-based IDs prevent collisions across branches and agents.
+- ✅ Protected-branch workflow uses `sync.branch` (this repo sets `beads-sync`) to keep metadata off `main`.
+
+### Configuration Notes
+
+- ✅ Tool-level config (Viper) uses flags/env/`.beads/config.yaml` for CLI behavior; project-level config uses `bd config` keys stored in the DB.
+- ✅ Prefer `bd config set|get|list` over manual YAML edits for project settings.
+- ✅ `sync.branch` controls protected-branch workflow; `flush-debounce` controls auto-export batching.
+- ✅ Actor resolution order: `--actor` → `BD_ACTOR` → `BEADS_ACTOR` → `git config user.name` → `$USER`.
+
+### CLI Reference (Quick)
+
+- ✅ Basics: `bd info --json`, `bd ready --json`, `bd list --json`, `bd show <id> --json`.
+- ✅ Updates: `bd create "Title" -t task -p 2 -d "Desc" --json`, `bd update <id> --status in_progress --json`, `bd close <id> --reason "Done" --json`.
+- ✅ Dependencies: `bd dep add <child> <parent> --type discovered-from`, or `bd create ... --deps discovered-from:<parent> --json`.
+- ✅ Global flags (prefix before command): `--json`, `--no-daemon`, `--no-auto-flush`, `--no-auto-import`, `--sandbox`, `--allow-stale`.
+
+### Git Workflow Reference
+
+- ✅ See `workflow.md` for git integration, worktrees, merge driver, hooks, and protected-branch workflow.
+
+<!-- END BEADS INTEGRATION -->
+
+
+## Build & Test
+
+_Add your build and test commands here_
+
+```bash
+# Example:
+# npm install
+# npm test
+```
+
+## Architecture Overview
+
+_Add a brief overview of your project architecture_
+
+## Conventions & Patterns
+
+_Add your project-specific conventions here_

data/CLAUDE.md

@@ -0,0 +1,111 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Is
+
+A Ruby gem for `netsuite-async-list`, wrapping the Oracle NetSuite SuiteTalk **SOAP Web Services API** via the Savon client. The `async-list` branch adds asynchronous bulk SOAP operations. **Note:** NetSuite is deprecating SOAP (final endpoint 2025.2, removed 2028.2). This gem is in maintenance mode.
+
+## Commands
+
+```bash
+# Run all tests
+bundle exec rspec
+# or
+bundle exec rake
+
+# Run a single spec file
+bundle exec rspec spec/netsuite/actions/async_add_list_spec.rb
+
+# Run with coverage
+bundle exec rake coverage
+
+# Integration tests (makes live NetSuite calls)
+NETSUITE_INTEGRATION=true bundle exec rspec
+
+# Build the gem
+bundle exec rake build
+```
+
+### Replaying a failed run
+When CI (or a local run) fails, the RSpec seed is in the output (e.g. "Randomized with seed 12345"). Re-run with that seed to reproduce the same order:
+```bash
+bundle exec rspec --seed 12345
+```
+Use `bundle exec rspec --only-failures` to re-run only the examples that failed last time (requires `tmp/rspec_examples.txt` from a previous run).
+
+There is no linter configured (no `.rubocop.yml`).
+
+## Architecture
+
+### Action Pattern
+Each SOAP operation is a class under `NetSuite::Actions`. Actions inherit `AbstractAction` and implement `action_name` + `request_body`. The `Support::Requests` mixin provides the `call` class method and response wrapping. Each action also has an inner `Support::ClassMethods` module that gets `include`d into record classes via the `actions(...)` DSL.
+
+### Async Operations (this branch)
+Two-phase pattern:
+1. **Submit** — `AsyncAddList.call(...)` returns `{ job_id:, status: 'pending' }`
+2. **Poll** — `CheckAsyncStatus.call([job_id])`
+3. **Fetch** — `GetAsyncResult.call([job_id, { page_index: 1 }])`
+
+The `AsyncResponse` module (in `actions/async_response.rb`) is mixed into all async action classes; it overrides response parsing for the `asyncStatusResult`/`asyncResult` SOAP envelope shape.
+
+### Record Composition
+Record classes compose behavior via `include`:
+- `Support::Fields` — `field`/`read_only_field`/`search_only_field` DSL
+- `Support::Records` — `to_record` serialization (snake_case attrs → camelCase SOAP XML)
+- `Support::Actions` — `actions(:get, :add, :async_add_list, ...)` DSL
+- `Namespaces::*` — SOAP namespace module per record type (e.g. `ListRel`, `TranSales`)
+
+### SOAP Endpoint
+This gem targets **SOAP v2025.2** — the final supported NetSuite endpoint (removed in 2028.2).
+
+There is no "current SOAP endpoint" stored in NetSuite. The endpoint you use is fully defined by **account ID + domain shard + SOAP version pinned in your code**. NetSuite doesn't choose this for you.
+
+Endpoint formula: `https://<account_id>.<domain>/services/NetSuitePort_<version>`
+
+Two config values pin the version:
+- **`api_version '2025_2'`** — controls SOAP namespace URIs in request envelopes (enforced; no other value accepted)
+- **`wsdl`** — WSDL Savon uses; local fixtures at `spec/support/fixtures/soap/v2025_2_0/`
+
+Production setup:
+```ruby
+NetSuite.configure do
+  account     ENV['NETSUITE_ACCOUNT']
+  api_version '2025_2'
+  wsdl        "https://#{ENV['NETSUITE_ACCOUNT']}.netsuite.com/wsdl/v2025_2_0/netsuite.wsdl"
+end
+```
+
+To verify: search the codebase for `api_version` / `wsdl`, or inspect the `POST /services/NetSuitePort_2025_2` in Savon request logs. If the hostname contains `sb1`/`sb2`, you're on a sandbox shard.
+
+### Configuration
+`NetSuite::Configuration` is `extend self` (module singleton). Multi-tenancy is supported via `Thread.current` namespacing.
+
+### Transport vs structure (Faraday migration)
+
+**Faraday** and **Nokogiri** are orthogonal: Faraday = *how bytes move* (HTTP client); Nokogiri = *how documents are understood* (XML parse/query). Savon bundled both plus SOAP semantics, which hid control and coupled Rack. Replacing Savon means keeping that boundary clear:
+
+- **Faraday**: open connection, POST body, return status + raw body. It does not care whether the body is XML or JSON.
+- **Nokogiri**: parse `resp.body` (from Faraday, disk, or anywhere), XPath/CSS, serialize. It does not care where the document came from.
+
+Flow: `resp = connection.post(...); doc = Nokogiri::XML(resp.body); parse(doc)`. No magic, no Rack, no SOAP abstraction leak. When adding a Faraday backend to `NetSuite::Client`, use Faraday for transport and Nokogiri only for request/response XML (build envelope, parse body into the same `#success?` / `#body` shape callers expect).
+
+### Key Locations
+- `lib/netsuite/client.rb` — single SOAP call boundary; today Savon, later swappable to Faraday + Nokogiri
+- `lib/netsuite/actions/` — all SOAP operation classes (sync + async)
+- `lib/netsuite/records/` — 200+ NetSuite record classes
+- `lib/netsuite/support/` — shared mixins (`Fields`, `Actions`, `Records`, `Requests`, etc.)
+- `lib/netsuite/configuration.rb` — Savon client config, auth, WSDL
+- `spec/support/fixtures/` — XML fixture files for Savon mock responses, one directory per action
+
+### Test Setup
+Tests use RSpec 3 with Savon's `SpecHelper` to mock SOAP calls. Each action spec loads XML fixtures from `spec/support/fixtures/<action_name>/`. Integration tests are tagged `:integration` and skipped unless `NETSUITE_INTEGRATION=true`.
+
+## Adding a New Action
+
+1. Create `lib/netsuite/actions/my_action.rb` inheriting `AbstractAction` (or an existing action for overrides)
+2. For async actions, `include AsyncResponse`
+3. Register in `lib/netsuite/support/actions.rb` (the `action(...)` DSL dispatch map)
+4. Add autoload in `lib/netsuite.rb`
+5. Add XML fixture in `spec/support/fixtures/my_action/`
+6. Write spec in `spec/netsuite/actions/my_action_spec.rb`

data/DEVELOPMENT.md

@@ -0,0 +1,34 @@
+# Development
+
+This repo prefers a repo-defined Ruby toolchain via Devbox.
+
+## Devbox (status & trade-offs)
+Devbox is considered a modern, valid way to manage per-project development environments, especially when you want reproducibility and consistent tooling across machines and CI. It’s actively developed and provides a reproducible shell by declaring tools in `devbox.json` (backed by Nix) without requiring contributors to write Nix expressions. ([Jetify][1])
+
+Trade-off: if you need maximum control, native Nix flakes/devshells are more flexible; Devbox is intentionally a simpler layer on top.
+
+References:
+- [Jetify (Devbox)][1]
+- [DevTools Guide overview][2]
+
+[1]: https://www.jetify.com/devbox
+[2]: https://www.devtoolsguide.com/devbox-reproducible-dev-environments/
+
+## Getting started
+- Install Devbox.
+- Enter the environment:
+  - `devbox shell`
+  - or (recommended) `direnv allow` if you use direnv.
+
+## Sanity checks
+From inside the Devbox environment:
+- `which ruby && ruby -v`
+- `which gem && gem --version`
+- `bundle -v`
+
+## Publishing (RubyGems)
+Devbox does not override `HOME` by default, so RubyGems credentials continue to live at `~/.gem/credentials`.
+
+Typical flow:
+- `gem build netsuite.gemspec`
+- `gem push netsuite-<version>.gem`

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+gemspec
+
+ruby '>= 3.1.0'
+
+group :development, :test do
+  gem 'rubyzip'
+  gem 'simplecov', require: false
+  gem 'debug'
+end