# Import and export workflows

Comind.work provides several ways to import data into and export data from your workspaces - from UI-based uploads to programmatic bulk operations.

## Importing records[​](#importing-records "Direct link to Importing records")

### From the UI[​](#from-the-ui "Direct link to From the UI")

Use the built-in data import feature to upload records from spreadsheet files:

1. Navigate to the target app in your workspace
2. Open the list menu and select **Import data**
3. Upload a CSV or XLSX file
4. Map file columns to app fields
5. Choose how to handle duplicates
6. Preview the results and confirm the import

### From the CLI[​](#from-the-cli "Direct link to From the CLI")

Two CLI commands are available for importing records:

**createRecords** - create new records from a file:

```
npx comind createRecords <app> <workspace> <file>
```

**importRecords** - import with full control over duplicate handling:

```
npx comind importRecords <app> <workspace> <file>
```

Duplicate handling modes:

| Mode   | Behavior                                           |
| ------ | -------------------------------------------------- |
| Block  | Fail the entire import if any duplicates are found |
| Skip   | Silently ignore duplicate records                  |
| Import | Update existing records (upsert)                   |

Action modes:

| Mode            | Behavior                                         |
| --------------- | ------------------------------------------------ |
| CreateAndUpdate | Create new records and update existing matches   |
| CreateOnly      | Only create, skip existing                       |
| UpdateOnly      | Only update, skip new                            |
| Preview         | Dry run - show what would happen without changes |

### From code (server-side)[​](#from-code-server-side "Direct link to From code (server-side)")

Use `ComindServer.importData()` in action code for programmatic imports:

```
await ComindServer.importData({
  wksAlias: "MY_WORKSPACE",
  appAlias: "CONTACTS",
  data: records,
  keyFields: ["external_id"],
  duplicateRow: "Import",          // 'Block' | 'Skip' | 'Import'
  importActions: "CreateAndUpdate", // 'CreateAndUpdate' | 'CreateOnly' | 'UpdateOnly' | 'Preview'
  fields: [
    { dataColumnName: "ext_name", storeInto: "title" },
    { dataColumnName: "ext_date", storeInto: "creation_date" }
  ]
});
```

Each entry in the `fields` array is an `ImportDataField` with properties including `dataColumnIndex`, `dataColumnName`, `isKey`, `storeInto`, `linkToMatchByFieldName`, `lookupMatchBy`, `userMatchBy`, `behaviourOnNoMatch`, `defaultValue`, and `csvDelimiter`.

## Importing list views[​](#importing-list-views "Direct link to Importing list views")

Import saved list view configurations (filters, columns, sort order) using the CLI:

```
npx comind importCustomViews
```

## Exporting data[​](#exporting-data "Direct link to Exporting data")

### From the UI[​](#from-the-ui-1 "Direct link to From the UI")

Export the current list view to Excel:

1. Open any list view
2. Click the **Export** button in the toolbar
3. The export respects your current filters, sorting, and visible columns

The export produces an XLSX file.

### From the CLI[​](#from-the-cli-1 "Direct link to From the CLI")

**dump** - export a running app schema back to TypeScript source files:

```
npx comind dump <app-id> <target-directory>
```

Converts compiled JavaScript back into editable TypeScript components (fields, actions, views, settings). Useful for migrating apps from the web editor to code-based development.

**dumpLint** - same as dump, with ESLint auto-formatting:

```
npx comind dumpLint <app-id> <target-directory>
```

## Managing app source code[​](#managing-app-source-code "Direct link to Managing app source code")

**push** - upload local source files to METAMETA storage:

```
npx comind push <app-name>
```

Diffs local files against remote and uploads only changes. Files are formatted with Prettier before upload.

**pull** - download app source to a local directory:

```
npx comind pull <app-name> <target-directory>
```

Use this to start coding an app that was originally created in the web editor.

## Zero-code to code workflow[​](#zero-code-to-code-workflow "Direct link to Zero-code to code workflow")

Move an app from the web editor to code-based development:

1. **Create** the app using the web UI editor
2. **Pull** the source: `npx comind pull my-app ./apps/my-app`
3. **Customize** in your IDE - add fields, actions, views
4. **Install** back to the workspace: `npx comind install my-app WORKSPACE`

Changes flow bidirectionally. Web editor changes can be pulled back to code, and code changes deploy via the install command.

## Related[​](#related "Direct link to Related")

* [Data import (end-user guide)](/user-guide/app-records-list/data-import.md) - how end users import records from spreadsheets via the UI
* [Data import and export (developer guide)](/developer-guide/how-to/advanced/data-import-export.md) - programmatic import/export patterns for app developers