autable

KO | EN

gitlite — search

#mysql #docker #rust #javascript #redis #anthropic #swift #sql #typescript #monitoring

(★ 9)

No description available.

File Explorer

ZIP Download

- - release.yml
- - server.mjs
- Dockerfile
- package-lock.json
- package.json
- README.md
- - main.go
- - main.go
- config.yml
- - remote-runner.md
- permissions.md
- - create_ticket.js
  - query_contacts.js
  - scan_device.js
- - hourly_ticket_sync.js
  - ticket_change_summary.js
- config.example.yml
- - ai.go
  - ai_reference.md
  - authorization.go
  - metadata_service.go
  - runners.go
  - runners_test.go
  - server.go
  - server_test.go
  - workflow_table_field_nodes.go
  - workflow_table_nodes.go
- - session.go
  - user.go
  - user_test.go
- - archive.go
  - leveldb.go
  - s3.go
  - service.go
  - service_test.go
  - sqlite.go
  - types.go
- - store.go
  - store_test.go
- - config.go
  - config_test.go
- - filestore.go
- - history.go
  - history_test.go
  - leveldb.go
  - leveldb_test.go
  - memory.go
- - stable.go
  - stable_test.go
- - client.go
  - client_test.go
- - metadata.go
  - metadata_test.go
- - permission.go
  - permission_test.go
- - jsonmap.go
  - repository.go
  - repository_test.go
- - atomic.go
  - git.go
  - git_test.go
  - layout.go
- - sync.go
  - sync_test.go
- - runnercli.go
  - runnercli_test.go
- - hub.go
  - hub_test.go
- - dsn.go
  - dsn_test.go
- - db.go
  - db_test.go
  - migrations.go
  - migrations_test.go
  - runnertoken.go
  - runnertoken_test.go
- - table.go
  - table_test.go
- - version.go
- - embed.go
  - handler.go
  - handler_test.go
- - node.go
  - node_test.go
  - remote.go
  - runner.go
  - runner_test.go
- - main.yml
- embed-web.sh
- - app.spec.ts
  - screenshots.spec.ts
  - start-backend.mjs
- - favicon.svg
- - api.ts
  - App.test.tsx
  - App.tsx
  - appState.test.ts
  - appState.ts
  - editorTypes.test.ts
  - editorTypes.ts
  - excelImport.test.ts
  - excelImport.ts
  - fieldPermissions.ts
  - formPdf.test.ts
  - formPdf.ts
  - formRuntime.test.ts
  - formRuntime.ts
  - i18n.ts
  - main.tsx
  - monacoLocal.ts
  - notifications.tsx
  - permissionState.ts
  - styles.css
  - tableGrid.test.ts
  - tableGrid.ts
  - tableViews.test.ts
  - tableViews.ts
  - vendor.d.ts
  - vite-env.d.ts
  - workflowConfig.test.ts
  - workflowConfig.ts
  - workflowInstances.test.ts
  - workflowInstances.ts
- index.html
- package-lock.json
- package.json
- playwright.config.ts
- tsconfig.json
- tsconfig.node.json
- vite.config.ts
.dockerignore
.gitignore
AGENTS.md
CLAUDE.md
Dockerfile
go.mod
go.sum
LICENSE
README.md

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

autable is a code-first alternative to multidimensional tables. The project is not a no-code or low-code builder: tables, forms, and workflows are stored as code-managed artifacts so AI-assisted development can work directly with the source of truth.

## Direction

- Go backend with SQLite for system/application data.
- LevelDB-compatible key/value storage for removable history/log data.
- TypeScript React frontend for table, workflow, and form surfaces.
- User-managed repository containing `config.yml`, table metadata, workflow JavaScript, and form JavaScript.

## Current Slice

This repository currently contains the backend core primitives:

- `config.yml` loading and validation, including password and OIDC auth toggles under `auth`.
- YAML metadata for databases and tables, including soft-deleted fields.
- Authenticated database/table creation that writes metadata YAML and grants database/table owner permissions.
- Hidden, auto-incrementing `ct_record_id` handling for user table storage.
- Per-metadata-database SQLite row persistence through GORM.
- Row create/update history written to LevelDB-compatible storage.
- Table views with composable `base_view`, filters, and sorts.
- Password registration/login with HttpOnly session cookies.
- OIDC provider listing plus authorization-code callback login with verified ID tokens and HttpOnly state/session cookies.
- Field-level permissions: none, read, write.
- Workflow and form resource permissions using their auto-incrementing IDs.
- User identity model with email fallback for password and OIDC accounts.
- History key generation and prefix scanning for row/workflow history.
- Stateless workflow node interface definitions.
- Workflow node metadata API and frontend node catalog for available stateless nodes and trigger nodes.
- Synchronous JavaScript workflow runs through registered stateless nodes, with each run persisted as `whistory_id_timestamp`.
- Remote runners: node instances can be bound (in the UI, beside instance variables/secrets) to a named `autable-runner` process that connects outbound over WebSocket and executes remote-capable nodes inside another network; a single resettable system token authorizes runners (see `docs/design/remote-runner.md`).
- A `kingdee.purchaseorder.list` node that pages purchase order lines out of Kingdee K3Cloud through a pure-Go WebAPI client (`internal/kingdee`) with request signing matching the official Python SDK.
- A `table.record.changed` trigger node that accepts an `rhistory_db_table_record_id_timestamp` key and exposes the decoded row change.
- Workflow JavaScript editing with JSON editors for GitHub Actions-style secrets and variables.
- Git-managed artifacts live under `repository.path`: table metadata at `metadata/main.yml`, workflow JavaScript at `workflow/<database>/<workflow>.js`, and form JavaScript at `form/<database>/<form>.js`.
- A form JavaScript runtime that requires `function render(api, root)` to render controls with `field` configs and return `{ table }`.
- Form submissions send input JSON; the backend executes the form JavaScript to resolve the target table and field-bound controls before writing records.
- Runtime data is rooted at `data.path`: `system.sqlite`, `leveldb`, and per-database `<database>.sqlite` files are derived from that directory instead of being configured separately.
- Excel import into tables, available from the table toolbar and from form scripts via `api.excelImport({ table, label, matchField, fields, duplicateStrategy })`: the file is parsed in the browser (SheetJS), users pick the worksheet and columns, missing `string`/`int`/`float` fields are auto-created through the field API, and rows are written serially through the existing create/upsert row APIs with per-row dedup on a match field (update or skip on duplicates).
- Form scripts can print: `api.pdf({ html, name, orientation, marginMm, table, record_id })` inside an action typesets the html into an A4 PDF, uploads it as a `file`, and returns the stored file so the script can write its id into a `file` field. The text stays selectable and searchable, which needs real glyphs, so `web/public/pdf` ships Noto Sans SC and the HarfBuzz subsetter: the characters the document renders are collected automatically and the font is cut down to them, keeping a page of Chinese around 30 KB. pdfmake, html-to-pdfmake, the font, and the subsetter all load on first use.
- Form controls support `api.relation({ onChange })` for filling other fields from a picked record, and `api.input({ disabled: true })` for values a script owns — rendered and submitted, but not typeable.
- A string field with `options` is an enum; adding `multiple: true` lets it hold several of them at once, stored comma-separated (so an option may not contain a comma). Multi-valued cells are edited as checkboxes in the row panel and in forms, and are left out of grid editing because a cell cannot show a set of choices.

## Development Rules

- This project is in active development; breaking changes are allowed.
- Do not preserve backward-compatible or legacy behavior unless explicitly requested.
- The product is live: existing databases must upgrade in place. The system database records a schema version; `migrations[i]` in `internal/systemdb/migrations.go` upgrades version i to i+1, runs unconditionally in a transaction, and may use raw SQL (the no-hand-written-SQL rule does not apply there). Migrations never probe for tables or columns — the version guarantees the starting state, and drift fails loudly. Append new migrations only; never edit or reorder released ones. Never ship a model change AutoMigrate cannot apply to populated tables, such as a new NOT NULL column without a default — that is what migrations are for.
- When changing a contract, update callers, tests, and docs to the new contract and remove the old path.
- Do not add fallback behavior for non-normal paths unless explicitly requested. Required data, metadata, and configuration failures should fail visibly instead of silently degrading to inferred or partial behavior.
- Use the ORM for database access; do not hand-write SQL in application code.
- All system timestamps are millisecond-precision 64-bit Unix timestamps.
- Table fields have no `required` concept; field types are immutable after creation.

## Development

```sh
go test ./...
```

Run the API server with git-managed config. On startup, Autable clones `repository.remote_url` at `repository.remote_branch` into `repository.path` when the path does not exist. After startup, local metadata, workflow, and form changes are committed and pushed to that remote branch; Autable does not pull or rebase remote changes automatically. The server loads metadata from `repository.path/metadata/main.yml` and stores runtime data under `data.path`:

```sh
cp examples/config.example.yml examples/config.yml
# Edit repository.remote_url and repository.remote_branch before starting.
go run ./cmd/autable -config examples/config.yml
```

Build a single Go binary with the frontend embedded:

```sh
cd web
npm install
cd ..
./scripts/embed-web.sh
go build -o autable ./cmd/autable
```

The binary serves the API and frontend on the same `server.address`.

Run the published Docker image:

```sh
docker run --rm \
  -p 8080:8080 \
  -v "$PWD/config.yml:/etc/autable/config.yml:ro" \
  -v autable-data:/data \
  -v autable-repository:/repository \
  ghcr.io/autable/autable:latest
```

The container uses `/etc/autable/config.yml`, listens on `0.0.0.0:8080`, stores runtime data under `/data`, and stores user-authored metadata/workflows/forms under `/repository`. Mount a config file that sets `repository.remote_url` and `repository.remote_branch`; an empty `/repository` volume is initialized by cloning the remote, or by creating the local branch when the remote repository is empty.

To debug memory or CPU in Docker, enable pprof in `config.yml`:

```yaml
debug:
  pprof_address: "0.0.0.0:6060"
```

Expose it only on localhost:

```sh
docker run --rm \
  -p 8080:8080 \
  -p 127.0.0.1:6060:6060 \
  -v "$PWD/config.yml:/etc/autable/config.yml:ro" \
  -v autable-data:/data \
  -v autable-repository:/repository \
  ghcr.io/autable/autable:latest
```

Then inspect profiles from the host:

```sh
go tool pprof http://127.0.0.1:6060/debug/pprof/heap
go tool pprof http://127.0.0.1:6060/debug/pprof/profile?seconds=30
curl http://127.0.0.1:6060/debug/pprof/goroutine?debug=2
```

Run the frontend:

```sh
cd web
npm install
npm run dev
```

Frontend verification:

```sh
cd web
npm test
npm run build
npm run e2e
```

Autable uses one shared S3-compatible bucket, configured once under `s3.connection`; each feature stores its objects under its own directory from `s3.directories`. Scheduled backups go under `s3.directories.backup` and user-uploaded files (the `file` field type) under `s3.directories.files`, where each upload lives at `<files directory>/<file id>/<file name>`. SQLite databases are copied with SQLite's online backup API, so the service does not need to stop while a backup is created. LevelDB history is optional; when `backup.include_leveldb` is enabled, Autable exports a consistent snapshot into a restorable LevelDB directory inside the archive:

```yaml
s3:
  connection:
    endpoint: "https://s3.example.com"
    region: "us-east-1"
    bucket: "autable"
    access_key_id: "..."
    secret_access_key: "..."
    force_path_style: true
  directories:
    backup: "backup"
    files: "files"

files:
  max_upload_size_mb: 20

backup:
  enabled: true
  interval: "24h"
  include_leveldb: false
  tmp_dir: "/tmp/autable-backups"
```

The project keeps generated runtime data out of git while keeping user-authored metadata, workflows, and forms in the configured repository remote.

autable

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README