Team & platformGuide

Git source control

A project can be linked to one Git repository on GitHub, GitLab or any Git server reached over HTTPS. Everything that describes the project becomes plain files there, and the repository becomes its source of truth: Waiso checks the branch every few minutes, shows what arrived, and one Accept makes the project what the repository holds. Sending works like the Source Control panel of a code editor: compare, stage, commit and push.

10 min readBefore this: Create a project, Publish the tested versionOpen in Waiso
What you will learn
  • Connect a repository with an HTTPS address and a token
  • Know which file each part of the project becomes — and what never travels
  • Stage, compare, commit and push your changes
  • Review what arrived from the repository and accept it
  • Start a second project (dev → production) from the same repository

The project as files

Waiso stays the place where code runs; the repository is where the project is described and where its history lives. Each item is written as one file, with the folder path the Code page shows. Only these files belong to the project: every other path in the repository — a README, a CI workflow, a test folder — is ignored, never listed, never read and never deleted.

Source control github.com/shop/docs-demo · main
From the repository · 2
Changes4History
Commit & Push
From the repository2
Aflows/campaign.flow.yaml
Dlegacy/old_sync.py
Accept 2 changes
Staged changes2
Mreports/report.py
A.waiso/schedules/weekly_report.yaml
Changes1
Mgreet.ts
Comparereports/report.py
Repository
1def main(day):2    rows = load(day)3    notify("ops")4    return rows
Project
1def main(day):2    rows = load(day)3    notify(TEAM)4    return rows
The Git page: what arrived from the repository above, your own changes below, the compare view beside them.
ItemFile in the repository
Python, TypeScript, JavaScript, C, C++ script<dir>/<name>.py, .ts, .js, .c, .cpp — the draft code, byte for byte
PostgreSQL / MySQL script<name>.pg.sql / <name>.mysql.sql
Flow<name>.flow.yaml, in the flow file format
Schedule.waiso/schedules/<name>.yaml
API endpoint.waiso/endpoints/<target path>.yaml
The project’s name.waiso/project.yaml
Variable.waiso/variables/<NAME>.yaml — name, description, whether it is secret
Integration.waiso/integrations/<name>.yaml — kind and name

Connect a repository

  1. Open the Git page

    In the project sidebar open Git and press Connect a repository.

  2. Give the address and the branch

    Paste the repository’s https:// address and the branch to follow. Addresses on private networks are refused.

  3. Add a token

    Create a token on your Git host that can write to this repository only and paste it with its username. The tutorial beside the form shows where each host keeps it.

  4. Check and connect

    Press Check and connect. Waiso reaches the repository, checks the token and the branch, and opens the Changes tab.

Connecting a project that already has items to an empty branch shows every item as Added: the first commit writes the whole project. Connecting an empty project to a branch that already holds one offers to bring everything at once — see Start from a repository.

Commit and push

The Changes tab lists what differs between the project and the branch, each file marked Modified, Added or Deleted. Click a file to compare the repository side with the project side.

  • Stage the files that belong in this commit, or Stage all. Committing with nothing staged asks whether to stage everything.
  • Write the Commit message and press Commit & Push (or Ctrl+Enter). The toast shows the new commit, Pushed 3f2a9c1.
  • The History tab lists the branch’s commits with the files each one touched.

Accept what arrived

With Check the repository automatically on (the default for a new connection, in the repository menu), Waiso looks at the branch every 5 minutes and when you open the project. When new commits arrive, the Git item in the project sidebar shows how many items are waiting, and the Git page lists them under From the repository with the commits they came from. Nothing changes until you accept.

  • Click a row to compare it. An item the repository removed is marked Will be deleted and its whole content shows in red: that is what would be lost.
  • used by N on a deletion names what still uses the item; replaces your unsent change marks an item you changed here and never sent.
  • Accept makes the project what the repository holds: new items are created, changed items are overwritten and published, removed items are deleted. Unsent changes it would replace are confirmed first, by name.
  • A file that does not read (a broken flow, a bad timetable) is skipped with its reason; everything else is applied.

Variables and integrations to fill in

A variable or integration that arrives is created with obviously fake values and marked To fill in on its page. A run never sees the placeholder: the variable is simply absent until you set the real value, and an integration answers integration_to_fill. One that already exists keeps its values — only its description follows the repository. New schedules and endpoints arrive off.

YAML.waiso/endpoints/reports/daily.yaml
target:
  script: reports/daily
path: daily-report
method: POST
mode: sync
auth: token
rateLimitPerMin: 60

Start from a repository

To make a second environment — a production project fed by the same branch as dev — create an empty project and connect it to that repository. Waiso recognises a Waiso project there and offers to Bring everything: it shows how many scripts, flows, schedules, endpoints, variables and integrations will come, and the name the project will take. After it, fill in the values the project lists and turn on the schedules you want.

Copies between projects

Without a repository, a script, flow or schedule can also be copied from another project of the workspace with Copy from another project on the Code and Schedules pages. What it uses comes along — the scripts a flow runs, a schedule’s target — and anything already at the same path is reused. A watched copy remembers its original: when the original is published again, the Git item counts it and the Git page offers Update (the copy takes the new version, published) or Ignore. Whoever publishes the original sees which projects watch it and can update each one.

Limits

  • One repository and one branch per project.
  • Only HTTPS addresses on public hosts; SSH keys are not supported.
  • One sync at a time per project: a second one answers Another sync of this project is running.
  • A commit is refused while something is waiting to be accepted — accept first, then send again.
  • Two items that map to the same file (the same name in the same folder) are reported and not written until one is renamed.
  • Connecting and disconnecting are reserved to admins and the project’s creator. Disconnecting removes only the link and the token — nothing is deleted on either side.

Related topics