DEV Community: Konsole

How We Built an AI-Powered Automated Product Enrichment Pipeline for Shopify

Konsole — Fri, 25 Apr 2025 09:11:00 +0000

Engineering a fully automated workflow for a Shopify store

Maintaining a successful e-commerce store comes with its fair share of challenges. It demands constant attention to ever-changing details across inventory, customer experience, and platform updates. With so many moving parts, manual oversight can quickly become overwhelming, error-prone, and time-consuming.

That’s where automation steps in — not just as a convenience but as a necessity to keep your store running efficiently and at scale. While Shopify offers a rich ecosystem of apps and drag-and-drop interfaces, it often requires you to trade transparency and control for convenience.

TL;DR

We’ll build a pipeline using GitHub Actions to export the latest products from the Shopify store, perform some actions using LLM, and update the products.

Full source for the pipeline can be found here.

Taking Back Control

Let the robots worry about the boring stuff!

Sooner or later, you will hit the limits with off-the-shelf apps and manual workflows and start looking for alternatives. One such alternative is to shift away from GUI-centric tools toward programmable pipelines that offer complete flexibility and control. What you want is:

Full ownership of your data
Enhancements tailored to your brand and products
Sharable Workflows: multiple stores could use the same workflow with little to no tweak
Confidence in every step of the process

Now, let’s explore how we can build an automated CI pipeline to help mitigate the issues mentioned above. As a proof-of-concept, we’ll create a pipeline to streamline our product-content workflow. The pipeline will use LLM to review the latest products on our store, optimize the title, add SEO title and description, and generate a summary for the team to review.

The Stack

Here’s what powers the workflow:

Shopify — where our products live
GitHub Actions — for orchestration and automation
ShopCTL — A command line utility for Shopify store management
OpenAI API — to revise product titles, generate SEO content, and suggestions
Python and some Bash scripts — for the enrichment logic and updates

First things first — Setting up the stack

Let’s start by setting up a GitHub Actions workflow. We’ll store pipeline configs in the .github/workflows/ directory. Create a file named enrich-products.yml inside the workflows directory. This file will define jobs for our product-content workflow.

# .github/workflows/enrich-products.yml

name: Shopify Product Enrichment

on:
  workflow_dispatch:

The workflow_dispatch event in GitHub Actions allows you to manually trigger a workflow from the GitHub interface or via the API , or you can schedule it to run automatically at a specific time.

API Keys

We’d need a few API keys to complete our configuration: OPENAI_API_KEY for AI operations and SHOPIFY_ACCESS_TOKEN to communicate with our store.

Get the OpenAI API key from your OpenAI account and set it as a secret in GitHub. Getting a Shopify access token is tricky since you need to create a dummy app to do so. Follow this official guide to get one.

ShopCTL

We’ll use a command-line tool to export and update our products. Let’s create a custom action that we can reuse to reference in our pipeline.

Create a file called setup-shopctl.yml inside actions directory and add the following config.

# .github/workflows/actions/setup-shopctl.yml

name: Setup ShopCTL
description: Installs Go and ShopCTL CLI
runs:
  using: "composite"
  steps:
    - name: Set up Go
      uses: actions/setup-go@v5
      with:
        go-version: "1.24"

    - name: Install ShopCTL
      shell: bash
      run: |
        sudo apt-get update
        sudo apt-get install -y libx11-dev
        go install github.com/ankitpokhrel/shopctl/cmd/shopctl@main
        echo "$HOME/go/bin" >> "$GITHUB_PATH"

Apart from custom actions, we need to add a configuration for the store we’re operating. Create a folder called shopctl on the repo’s root and add the following config in a file called .shopconfig.yml. Replace all occurrences of store1 with your store alias.

# shopctl/.shopcofig.yml

ver: v0
contexts:
    - alias: store1
      store: store1.myshopify.com
currentContext: store1

Finalizing the pipeline

Our pipeline has four stages, viz: Export -> Enrich -> Update -> Notify

Stage 1: Export products

The first step in our pipeline is to export the latest products from our store. Add a job called export-products in the enrich-products.yml file we created earlier.

jobs:
  export-products:
    runs-on: ubuntu-latest
    env:
      SHOPIFY_ACCESS_TOKEN: ${{ secrets.SHOPIFY_ACCESS_TOKEN }} # The secret we set earlier
      SHOPIFY_CONFIG_HOME: ${{ github.workspace }} # This will tell shopctl to use current dir to look for .shopconfig
    outputs:
      has-data: ${{ steps.check.outputs.has_data }}

    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - name: Setup ShopCTL
        uses: ./.github/workflows/actions/setup-shopctl

      - name: Export products
        run: |
          mkdir -p data

          # Export latest data (last 7 days) using the shopctl tool as latest_products.tar.gz
          shopctl export -r product="created_at:>=$(date -v -7d +%Y-%m-%d)" -o data/ -n latest_products -vvv

      - name: Check if export has data
        id: check
        run: |
          if [ -s data/latest_products.tar.gz ]; then
            echo "has_data=true" >> "$GITHUB_OUTPUT"
          else
            echo "has_data=false" >> "$GITHUB_OUTPUT"
            echo "No products found to process"
          fi

      - name: Upload exported products
        if: steps.check.outputs.has_data == 'true'
        uses: actions/upload-artifact@v4
        with:
          name: exported-products
          path: data/latest_products.tar.gz

The job above will set up ShopCTL using the custom action we created earlier. It will export all products created in the last 7 days and upload them as artifacts if any new products exist.

Stage 2a: Review catalog

The next we want to do is to review our catalog. We’ll use OpenAI API to review product data samples and identify the following:

Issues or inconsistencies in tags, product types, or variants
Missing or inconsistent inventory information
Gaps in product configuration or variant structure
Duplicate or overly similar products
General recommendations to improve catalog quality and its completeness

review-catalog:
    needs: export-products
    runs-on: ubuntu-latest
    env:
      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - name: Download product export
        uses: actions/download-artifact@v4
        with:
          name: exported-products
          path: data/

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.13"

      - name: Install dependencies
        run: pip install openai

      - name: Run catalog review script
        run: |
          # Assuming your script is saved in scripts/review_catalog.py
          python scripts/review_catalog.py \
            data/latest_products.tar.gz \
            data/review_summary.md

      - name: Upload catalog summary
        uses: actions/upload-artifact@v4
        with:
          name: catalog-review-summary
          path: data/review_summary.md

      - name: Final summary
        run: echo "✅ Shopify product catalog review completed!"

Notice the needs section. We want to run it after products are exported and made available as artifacts. We also need to set up Python, as our review script is written in Python. You can use any language of your choice here. The script generates review_summary.md, which is uploaded as an artificat in the next step (example output below).

## Identified Issues

### 1. Missing or Inconsistent Information:
- Some products have missing or inconsistent `productType` (e.g. `"gid://shopify/Product/8790718087392"`, `"gid://shopify/Product/879071795632

The sample script and the prompt can be found here.

Stage 2b: Enrich Products

Similar to the review-catalog job, add an enrich-products job that will run the script to review the product title and generate an SEO title and description for the product using OpenAI. This job runs in parallel with the review catalog job and generates a CSV with details on metadata to update.

The sample script and the prompt can be found here.

Stage 3: Update products

Once the metadata is generated in stage 2b, we can update products using ShopCTL. We’ll use a bash script instead of Python at this stage.

Add a job called update-products, as shown below.

update-products:
    needs: enrich-products
    runs-on: ubuntu-latest
    env:
      SHOPIFY_ACCESS_TOKEN: ${{ secrets.SHOPIFY_ACCESS_TOKEN }}
      SHOPIFY_CONFIG_HOME: ${{ github.workspace }}

    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - name: Setup ShopCTL
        uses: ./.github/workflows/actions/setup-shopctl

      - name: Download enriched products
        uses: actions/download-artifact@v4
        with:
          name: enriched-products
          path: data/

      - name: Apply updates using shopctl
        run: |
          mkdir -p logs
          touch logs/audit.txt

          while IFS=, read -r pid new_title seo_title seo_desc; do
            # Strip leading/trailing quotes
            seo_desc="${seo_desc%\"}"
            seo_desc="${seo_desc#\"}"

            # Use shopctl to update product details
            if output=$(shopctl product update "$pid" \
                --title "$new_title" \
                --seo-title "$seo_title" \
                --seo-desc "$seo_desc" 2>&1); then
                echo "$pid,success" >> logs/audit.txt
            else
              sanitized_error=$(echo "$output" | tr '\n' ' ' | sed 's/,/ /g')
              echo "$pid,failure,$sanitized_error" >> logs/audit.txt
            fi
          done < <(tail -n +2 data/enriched_products.csv)

        - name: Upload audit log
          uses: actions/upload-artifact@v4
          with:
            name: product-audit-log
            path: logs/audit.txt

        - name: Final summary
          run: echo "✅ Shopify product enrichment and updates completed!"

The job is relatively simple; it uses a bash script to read from the CSV file generated in the previous step, update the product using ShopCTL, and create a log file.

Stage 4: Notify

Now, the only thing remaining is to notify interested parties that the job has been completed (or failed) and what has changed. You can either send a Slack notification or email the details. We will simply fetch and print the logs for the tutorial’s sake.

notify:
    needs: [review-catalog, update-products]
    runs-on: ubuntu-latest

    steps:
      - name: Download audit log
        uses: actions/download-artifact@v4
        with:
          name: product-audit-log
          path: logs/

      - name: Download catalog review
        uses: actions/download-artifact@v4
        with:
          name: catalog-review-summary
          path: data/

      - name: Print audit summary
        run: |
          ls -lah logs/
          ls -lah data/
          echo "🧾 Shopify Product Update Audit"
          echo "-------------------------------"

          total=$(wc -l < logs/audit.txt)
          updated=$(grep -c ',success' logs/audit.txt || true)
          failed=$(grep -c ',failure' logs/audit.txt || true)

          echo "✅ Success: $updated"
          echo "❌ Failed: $failed"
          echo "📦 Total Processed: $total"
          echo ""
          echo "📋 Detailed Audit:"
          cat logs/audit.txt

      - name: Print catalog review summary
        run: |
          echo ""
          echo "🧠 Catalog Review Summary"
          echo "-------------------------"
          cat data/review_summary.md

Putting It All Together

The example above showcase how you can leverage available tools to create something unique and powerful tailored to your use case without handing over sensitive store data to external apps.

While our proof-of-concept skips over a few production-grade essentials — like using a staging store for manual approvals and proper error handling — it gives you a general idea of how to get started.

Takeaway

This level of flexibility and control opens up limitless possibilities — from automated A/B testing on product copies, multi-language enrichment workflows, dynamic pricing experiments, and automated inventory cleanup to personalized recommendations and beyond.

With every step in your control, you can experiment with new ideas, adapt quickly to market shifts, and scale operations effortlessly as your business grows.

ShopCTL: A Developer-First Toolkit for Shopify Automation

Konsole — Tue, 15 Apr 2025 21:11:00 +0000

Shopify at your fingertips with shell automation

Learning Shopify has been on my bucket list for a few years now. Plenty of people in my circle — friends, colleagues, and fellow devs — are all somehow involved with Shopify in one way or the other. Earlier this year, I finally had some breathing room between projects, so I figured it was the perfect time to give Shopify a proper look.

I started exploring the platform by setting up a dev store, poking around the admin, and skimming through the API manual. While this was a quick and easy start, it didn’t give me a deeper understanding of the platform. Plus, clicking my way through the UI felt repetitive and tedious.

That got me thinking: is there a more efficient, developer-centric way to manage a store? Something that I could run in a terminal, plug into a CI/CD pipeline, or script my way out of those mundane tasks.

Meet ShopCTL

ankitpokhrel / shopctl

🛠️ [WiP] Manage Shopify store straight from the terminal

ShopCTL

[WiP] Command line Utility for Shopify Data Management

ShopCTL is a slightly opinionated, in-progress command-line utility for managing your Shopify store data. It comes with a handful of easy-to-compose commands giving you a quick way to interact with your store's data straight from the terminal.

Installation
Resources
Getting started
Usage
Commands
- Export
- Import
- Product
- Customer
- Webhook
Development

Installation

Create a dummy app from the Shopify Partners Dashboard and get the client ID and secret.
- Add http://127.0.0.1/shopctl/auth/callback to the list of Allowed redirection URL(s)
- Make sure to request for required scopes
See #3 for detailed instructions on how to setup an app for client ID and secret.

Export client ID and secret from the first step to your shell.

export SHOPCTL_CLIENT_ID=<client-id>
export SHOPCTL_CLIENT_SECRET=<client-secret>

Install the runnable binary to your $GOPATH/bin.
```
go
```
…

View on GitHub

ShopCTL is an in-progress command-line utility for managing your Shopify store data. It comes with a handful of easy-to-compose commands, giving you a quick way to interact with your store’s data straight from the terminal.

Simply put, it’s like a Swiss Army knife for your Shopify store — giving you quick, scriptable commands to query and modify products, customers, and more (upcoming).

Quick Feature Highlights

ShopCTL currently comes with product and customer-related commands. The tool is POSIX-compliant, giving you a familiarity with standard Unix command-line operations. The CLI flags are designed such that you can combine available flags in any order to create a unique query. For instance, the command below will give you all gift-cards on status DRAFT that were created after January 2025 and have tags on-sale and premium.

shopctl product list --gift-card -sDRAFT --tags on-sale,premium --created ">=2025–01–01"

The list commands also accept queries in a Shopify Search query syntax as the first argument. That means you can build a complex search query as needed for your use case.

# List products using combination of raw query and available flags
shopctl product list "(title:Caramel Apple) OR (inventory_total:>500 inventory_total:<=1000)" --tags premium

In addition to advanced searching, you can create, update, delete, export, and import products — including their options, variants, and media — and most of these features also apply to customers. A handy peek command is available to give you a quick glance at product details right from your terminal. Support for other resources might be added in the future as needed.

Automation and Scripting Use-cases

Let’s explore some possible real-life use cases.

True power in scripting isn’t just about automating tasks — it’s the belief that even the simplest code can create wonders. — Not me

Seasonal pricing updates

Seasonal sales are great for business, but updating prices for a whole collection can be tedious. A CLI tool could make it easy to script bulk price adjustments. For example, suppose you want to apply a 30% discount to all products tagged with “summer-sale” for a summer sale:

#!/usr/bin/env bash

for product_id in $(shopctl product list --tags summer-sale --columns=id --plain --no-headers); do
    shopctl product variant list "$product_id" --columns=id,price --plain --no-headers | \
    while read variant_id price; do
        new_price=$(echo "$price * 0.7" | bc)
        shopctl product variant edit "$product_id" --id "$variant_id" --price "$new_price"
    done
done

Automated Inventory Discounts for Clearance

Ever have excess inventory you want to clear out? With ShopCTL, you can easily look for and flag or discount overstocked items. Let’s say any product with more than 100 units in stock should get a 20% price drop and a “clearance” tag. We can achieve this by filtering on inventory and then updating those products:

#!/usr/bin/env bash

for product_id in $(shopctl product list "inventory_total:>=100" --columns=id --plain --no-headers); do
    shopctl product variant list "$product_id" --columns=id,price --plain --no-headers | \
    while read variant_id price; do
        new_price=$(echo "$price * 0.8" | bc) # 20% discount
        shopctl product variant edit "$product_id" --id "$variant_id" --price "$new_price"
    done
    shopctl product update "$product_id" --tags "clearance" # Add clearance tag
done

Data Cleanup & Dynamic Tagging

Data cleanup is another area where scripting shines. As your product catalog grows, keeping track of what’s selling and what’s just sitting in inventory becomes harder. Why not tag these products based on specific conditions, like high inventory and older creation dates, and act upon it without manually digging through product listings?

# Add 'slow-moving' tag to products with high inventory created before 2025
shopctl product list "inventory_total:>=500" --created "<2025-01-01" --columns=id --plain --no-headers \
  | xargs -I{} shopctl product update {} --tags slow-moving

Another use-case could be to archive products with missing SKUs. Suppose you want to find any products that have missing SKUs (perhaps products that were created without proper variant SKUs) and archive them so they don’t clutter your active catalog. You can search for products with empty SKU fields and update their status in bulk with some simple bash scripts:

#!/usr/bin/env bash

for product_id in $(shopctl product list --sku "" --columns=id --plain --no-headers); do
  shopctl product update "$product_id" --status archived
done

How about something as simple as quickly finding and deleting stale DRAFT products to keep your catalog clean?

# Remove all drafts older than 90 days
shopctl product list -sDRAFT — created “<=$(date -v -90d +%Y-%m-%d)” \
 | xargs -I{} shopctl product delete {}

Attaching Media to Products via CSV

Attaching images or other media to products in bulk can be cumbersome through the web UI. Let’s say a client provides you a CSV file with relevant columns like a product ID/handle and a URL to an image that needs to be attached to that product. You can perform media attachments in bulk with a simple bash script.

# Sample csv
product_id,image_url,alt,media_type
12345,https://example.com/image1.jpg,Front view,image
12345,https://example.com/video1.mp4,Demo video,video
56789,https://example.com/image1.jpg,Front view,image

#!/usr/bin/env bash

# Skip the CSV header and process each row
tail -n +2 images.csv | while IFS=, read -r product_id image_url alt media_type; do
  media_type_upper=${media_type^^} # Convert media_type to uppercase
  shopctl product media attach "$product_id" --url "$image_url" --alt "$alt" --media-type "$media_type_upper"
done

Exporting and Importing Customer Data

Last but not least, consider the task of exporting customer data for a marketing campaign or migrating customers to a new store. ShopCTL has you covered with built-in export/import for customers as well. For example, to export all customers from one store and import them into another:

shopctl export -c store1 -r customer="created:>2025-01-01 AND created:<2025-04-01" -o /backups -n customers_this_quarter
shopctl import -c store2 -r customer -f /backups/customers_this_quarter.tar.gz

Wrapping Up

The possibilities with scripting are endless — you can shape it to fit your own workflows and solve unique use cases. The examples above are just the start. As the tool matures, it will open the door to some advanced automation and workflows.

Learn more

Check out the project page to view the full set of features and learn more about the project.

Your suggestions and feedback are highly appreciated. Feel free to start a discussion or create an issue to share your experience with the tool or to discuss a feature/issue. If you think this project is useful, consider contributing by starring the repo, sharing it with your friends, or submitting a PR.

JiraCLI: Interactive command line for Atlassian Jira reached v1.0.0

Konsole — Sun, 03 Jul 2022 19:33:24 +0000

JiraCLI v1.0 supports a wide variety of new commands, authentication with personal access tokens (PAT), OS keychain & .netrc for accessing credentials, custom fields, and many more.

My goal with Jira CLI was to build a simple tool based on my personal Jira workflow that would allow me to seamlessly complete the most common developer workflows end-to-end in the terminal.

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Feature-rich Interactive Jira Command Line

Financial support from private and corporate sponsors ensures the tool's continued development.
Please consider sponsoring the project if you or your company rely on JiraCLI

Supporters

JiraCLI is an interactive command line tool for Atlassian Jira that will help you avoid Jira UI to some extent. This tool may not be able to do everything, but it has all the essential features required to improve your day-to-day workflow with Jira.

The tool started with the idea of making issue search and navigation as straightforward as possible. However, with the help of outstanding supporters like you, we evolved, and the tool now includes all necessary features like issue creation, cloning, linking, ticket transition, and much more.

This tool is heavily inspired by the GitHub CLI

Supported platforms

Note that some features might work slightly differently in cloud installation versus on-premise installation due to the…

View on GitHub

The project started as an experiment over the weekends with the idea of making issue search and navigation as straightforward as possible. Over the course of several months, I switched teams/companies, worked with different kinds of workflows, and kept improving the tool to adapt to various use cases.

The tool is far from perfect, and I would not consider it complete. But it has all the necessary features to improve your workflow with Jira. The app supports both cloud and on-premises Jira instances. Regardless of the differences between these installations, I've tried to keep the overall experience as similar as possible.

The project has gained some traction over the past months, and I think this was a great time to release a stable version. I believe that this will allow everyone to integrate the tool into their daily workflows/pipelines confidently.

Moving forward, the focus will be on fixing some of the long-standing bugs, adding more features, and revamping the TUI to add more actions. Any sort of contribution is heartily welcome.
Lastly, huge thanks to all contributors. This would not have been possible without all the help.

View the release notes or install and start using JiraCLI.

Jira CLI: New version adds support for on-premise jira installation

Konsole — Mon, 01 Nov 2021 18:23:15 +0000

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Feature-rich Interactive Jira Command Line

Financial support from private and corporate sponsors ensures the tool's continued development.
Please consider sponsoring the project if you or your company rely on JiraCLI

Supporters

This tool is heavily inspired by the GitHub CLI

Supported platforms

Note that some features might work slightly differently in cloud installation versus on-premise installation due to the…

View on GitHub

A new version of Jira CLI, v0.1.0, is now available with most requested support for the on-premise jira installation.

What's Changed

feat: On-premise/local jira installation is almost fully supported 🎉
feat: Allow Tab to toggle focus between the sidebar and the contents screen
feat: Command to generate UNIX style man pages for section 7
fix: Cursor in terminal disappears if command exits with error
Some minor enhancements, fixes and upgrades

Full change log can be found in the release page.

Jira CLI: The Missing Command-line Tool for Atlassian Jira

Konsole — Sat, 16 Oct 2021 13:52:48 +0000

The original version of this post first appeared in Medium.

The year is 2078 and there have been 0 improvements in the Jira UI — #rant

Jira UI is terrible to work with. It is slow, buggy, and doesn’t even load on occasions. If you have to rely on it for your day-to-day job it is going to cost you a lot of time and frustration. These frustrations pile up if you need to create tickets, in a pre-defined format with proper labels, components, etc, for every change you make, even a typo!

Since I spend a significant amount of my time in the command-line, this is my small attempt to make Jira experience better for the CLI users.

Introducing Jira CLI

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Feature-rich Interactive Jira Command Line

Financial support from private and corporate sponsors ensures the tool's continued development.
Please consider sponsoring the project if you or your company rely on JiraCLI

Supporters

This tool is heavily inspired by the GitHub CLI

Supported platforms

Note that some features might work slightly differently in cloud installation versus on-premise installation due to the…

View on GitHub

TLDR; Features Highlight

Interactive mode + an option to easily integrate with shell/automation scripts using standard POSIX-complaint flags.
Easy search and navigation. For instance, you can easily search for something like “Issues that are of high priority, is in progress, was created this month, and has a label called backend” with jira issue list -yHigh -s"In Progress" --created month -lbackend
Create a neat Jira ticket (and comment) using Github-flavored + Jira-flavored markdown as a template. Supports pre-defined templates.
The ticket details are translated to markdown from the Atlassian document and is beautifully displayed on the screen when you view it.
Easy sprint and epic navigation. You can quickly view tickets in previous, current, and next sprint tickets using flags like --prev, --next, and --current eg: jira sprint list --current.
Fast and straightforward ticket cloning with the ability to replace text in summary and description.
You can edit, link, assign and transition the issues with ease.
Supports multiple Jira servers using --config flag or XDG_CONFIG_HOME env.

Disclaimer

The tool is mosty tested with the latest Jira cloud since that’s what I usually work with. However, the support for on-premise Jira installation is on the way.

Also, the tool is still a work in progress with some exciting features in the todo pipeline.

Searching for an Issue

JiraCLI makes searching for an issue as easy as it should be. The lists are displayed in an interactive UI and can be navigated easily to perform actions like viewing, navigating, and copying issue keys/links.

The examples below shows how easy it is to look for an issue. See more examples here.

# List issues that I am watching in the current board
$ jira issue list -w

# List issues assigned to me
$ jira issue list -a$(jira me)

# List issues created within an hour and updated in the last 30 minutes️
$ jira issue list --created -1h --updated -30m

# Give me issues that are of high priority, is in progress, was created this month, and has given labels 🔥
$ jira issue list -yHigh -s"In Progress" --created month -lbackend -l"high prio"

# Wait, what was that ticket I opened earlier today? 😫
$ jira issue list --history# What was the first issue I ever reported on the current board? 🤔
$ jira issue list -r$(jira me) --reverse

# What was the first bug I ever fixed in the current board? 🐞
$ jira issue list -a$(jira me) -tBug sDone -rFixed --reverse

# What issues did I report this week? 🤷‍♂️
$ jira issue list -r$(jira me) --created week

Creating an Issue

The create command lets you create an issue and supports Github-flavored and Jira-flavored markdown for writing descriptions. You can load pre-defined templates using --template flag.

# Create an issue using interactive prompt
$ jira issue create

# Pass required parameters to skip prompt or use --no-input option
$ jira issue create -tBug -s"New Bug" -yHigh -lbug -lurgent -b"Bug description"

# Load description from template file
$ jira issue create --template /path/to/template.tmpl

The preview below shows the markdown template passed in JiraCLI and the way it is rendered in the Jira UI.

Viewing an Issue

The view command lets you see issue details in a terminal. Atlassian document is roughly converted to a markdown and is nicely displayed in the terminal.

$ jira issue view ISSUE-1

Assigning a user to an issue

The assign command lets you easily assign and unassign users to and from the issue.

# Assign user to an issue using interactive prompt
$ jira issue assign

# Pass required parameters to skip prompt
$ jira issue assign ISSUE-1 "Jon Doe"

# Assign to self
$ jira issue assign ISSUE-1 $(jira me)

# Will prompt for selection if keyword suffix returns multiple entries
$ jira issue assign ISSUE-1 suffix

# Assign to default assignee
$ jira issue assign ISSUE-1 default

# Unassign
$ jira issue assign ISSUE-1 x

Cloning an Issue

The clone command lets you clone an issue. You can update fields like summary, priority, assignee, labels, and components when cloning the issue. The command also allows you to replace a part of the string (case-sensitive) in summary and description using --replace/-H option.

# Clone an issue
$ jira issue clone ISSUE-1

# Clone issue and modify the summary, priority and assignee
$ jira issue clone ISSUE-1 -s"Modified summary" -yHigh -a$(jira me)

# Clone issue and replace text from summary and description
$ jira issue clone ISSUE-1 -H"find-me:replace-with-me"

Sprints

Sprints are displayed in an explorer view by default. You can output the results in a table view using the --table flag. When viewing sprint issues, you can use all filters available for the issue command. You can quickly view tickets in previous, current, and next sprint tickets using flags like --prev, --next, and --current.

# Display sprints in an interactive list
$ jira sprint list

# Display tickets in the current active sprint
$ jira sprint list --current

# Display tickets in the previous sprint
$ jira sprint list --prev

# Display tickets of a particular sprint
$ jira sprint list <SPRINT_ID>

Learn more

Check out the project page to view the full set of features and learn more about the project.

Your suggestions and feedback is highly appreciated. Feel free to start a discussion or create an issue to share your experience about the tool or to discuss a feature/issue. If you think this project is useful, consider contributing by starring the repo, sharing with your friends, or submitting a PR.

Resumable file upload in PHP: Handle large file uploads in an elegant way

Konsole — Sun, 02 Dec 2018 10:33:39 +0000

Ever struggled with large file upload in PHP? Wondered if you could continue uploading where you left off without re-uploading whole data again in case of any interruptions? If this sounds familiar to you, then keep reading.

File upload is a common task we do in almost all of our modern web projects. With all different tools available, it is not that hard to implement file upload feature in any language. But, still, when it comes to large file upload things gets a bit complicated.

Say, you are trying to upload a fairly large file. You have been waiting for more than an hour already and the upload is at 90%. Then suddenly, your connection drops or browser crashed. The upload is aborted and you need to start from the beginning. Frustrating, isn't it? Even worse, if you are in a slow connection, like many places in the world, no matter how often you try you will only be able to upload first part of the upload every time.

In this post, we will see an attempt to solve this problem in PHP by uploading files in resumable chunks using tus protocol.

What is tus?

Tus is a HTTP based open protocol for resumable file uploads. Resumable means we can carry on where we left off without re-uploading whole data again in case of any interruptions. An interruption may happen willingly if the user wants to pause, or by accident in case of a network issue or server outage.

Tus protocol was adopted by Vimeo in May 2017.

Why tus?

Quoting from Vimeo's blog:

We decided to use tus in our upload stack because the tus protocol standardizes the process of uploading files in a concise and open manner. This standardization will allow API developers to focus more on their application-specific code, and less on the upload process itself.

Another main benefit of uploading a file this way is that you can start uploading from a laptop and even continue uploading the same file from your mobile or any other device. This is a great way to enhance your user experience.

Basic Tus Architecture

Getting Started

Let's start by adding our dependency.

$ composer require ankitpokhrel/tus-php

tus-php is a framework agnostic pure PHP server and client implementation for the tus resumable upload protocol v1.0.0.

ankitpokhrel / tus-php

🚀 A pure PHP server and client for the tus resumable upload protocol v1.0.0

TusPHP

Resumable file upload in PHP using tus resumable upload protocol v1.0.0

Medium Article ⚡ Laravel & Lumen Integration ⚡ Symfony Integration ⚡ CakePHP Integration ⚡ WordPress Integration

tus is a HTTP based protocol for resumable file uploads. Resumable means you can carry on where you left off without re-uploading whole data again in case of any interruptions. An interruption may happen willingly if the user wants to pause, or by accident in case of a network issue or server outage.

Installation

Pull the package via composer.

$ composer require ankitpokhrel/tus-php
// Use v1 for php7.1, Symfony 3 or 4.

…

View on GitHub

Update: Vimeo is now using TusPHP in v3 of their Official PHP library for the Vimeo API.

Creating a server to handle our requests

This is how a simple server looks like.

// server.php
$server   = new \TusPhp\Tus\Server('redis');

$response = $server->serve();

$response->send();

exit(0); // Exit from current PHP process.

You need to configure your server to respond to a specific endpoint. For example, in Nginx, you would do something like this:

# nginx.conf

location /files {
    try_files $uri $uri/ /path/to/server.php?$query_string;
}

Let's assume that the URL to our server is http://server.tus.local. So, based on above nginx configuration we can access our tus endpoints using http://server.tus.local/files.

Now, we have following RESTful endpoints available to work with.

# Gather information about server's current configuration
OPTIONS /files

# Check if the given upload is valid
HEAD /files/{upload-key}

# Create a new upload
POST /files

# Resume upload created with POST
PATCH /files/{upload-key}

# Delete the previous upload
DELETE /files/{upload-key}

Check out the protocol details for more info about the endpoints.

If you are using any frameworks like Laravel, instead of modifying your server config, you can define routes to all tus based endpoints in your framework route file. We will cover this in detail in another tutorial.

Handling upload using tus-php client

Once the server is in place, the client can be used to upload a file in chunks. Let us start by creating a simple HTML form to get input from the user.

<form action="upload.php" method="post" enctype="multipart/form-data">
    <input type="file" name="tus_file" id="tus-file" />
    <input type="submit" value="Upload" />
</form>

After a form is submitted, we need to follow few steps to handle the upload.

1. Create a tus-php client object

// Tus client
$client = new \TusPhp\Tus\Client('http://server.tus.local');

The first parameter in the above code is your tus server endpoint.

2. Initialize client with file metadata

To keep an upload unique, we need to use some identifier to recognize the upload in upcoming requests. For this, we will have to generate a unique upload key which can be used to resume the upload later. You can either explicitly provide an upload key or let the system generate a key by itself.

// Set upload key and file meta
$client->setKey($uploadKey)
    ->file($_FILES['tus_file']['tmp_name'], 'your file name');

If you don't provide upload key explicitly, above step will be something like this:

$client->file($_FILES['tus_file']['tmp_name'], 'your file name');

$uploadKey = $client->getKey(); // Unique upload key

3. Upload a chunk

// $chunkSize is size in bytes, i.e. 5000000 for 5 MB
$bytesUploaded = $client->upload($chunkSize);

Next time, when you want to upload another chunk you can use same upload key to continue.

// To resume upload in next request
$bytesUploaded = $client->setKey($uploadKey)->upload($chunkSize);

Once the upload is complete, the server verifies upload against the checksum to make sure the uploaded file is not corrupt. The server will use sha256 algorithm by default to verify the upload.

The full implementation of the demo video above can be found here.

Handling upload using tus-js-client

Uppy is a sleek, modular file uploader plugin developed by same folks behind tus protocol. You can use uppy to seamlessly integrate official tus-js-client with a tus-php server. That means we are using php implementation of a server and js implementation of a client.

uppy.use(Tus, {
  endpoint: 'https://server.tus.local/files/', // your tus endpoint
  resume: true,
  autoRetry: true,
  retryDelays: [0, 1000, 3000, 5000]
})

Check out more details in uppy docs and example implementation here.

Partial Uploads

The tus-php Server supports concatenation extension and is capable of concatenating multiple uploads into a single one enabling clients to perform parallel uploads and to upload non-contiguous chunks.

The full example of partial uploads can be found here.

Final Words

The tus-php project itself is still in its initial stage. Some sections might change in the future. Three different implementation examples can be found in the example folder. Feel free to try and report any issues found. Pull requests and project recommendations are more than welcome.

Happy Coding!

DEV Community: Konsole

How We Built an AI-Powered Automated Product Enrichment Pipeline for Shopify

Taking Back Control

The Stack

First things first — Setting up the stack

API Keys

ShopCTL

Finalizing the pipeline

Stage 1: Export products

Stage 2a: Review catalog

Stage 2b: Enrich Products

Stage 3: Update products

Stage 4: Notify

Putting It All Together

Takeaway

ShopCTL: A Developer-First Toolkit for Shopify Automation

Meet ShopCTL

ankitpokhrel / shopctl

🛠️ [WiP] Manage Shopify store straight from the terminal

ShopCTL

Table of Contents

Installation

Quick Feature Highlights

Automation and Scripting Use-cases

Seasonal pricing updates

Automated Inventory Discounts for Clearance

Data Cleanup & Dynamic Tagging

Attaching Media to Products via CSV

Exporting and Importing Customer Data

Wrapping Up

Learn more

JiraCLI: Interactive command line for Atlassian Jira reached v1.0.0

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Supporters

Supported platforms

Jira CLI: New version adds support for on-premise jira installation

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Supporters

Supported platforms

What's Changed

Jira CLI: The Missing Command-line Tool for Atlassian Jira

Introducing Jira CLI

ankitpokhrel / jira-cli

🔥 Feature-rich interactive Jira command line.

JiraCLI

Supporters

Supported platforms

TLDR; Features Highlight

Disclaimer

Searching for an Issue

Creating an Issue

Viewing an Issue

Assigning a user to an issue

Cloning an Issue

Sprints

Learn more

Resumable file upload in PHP: Handle large file uploads in an elegant way

What is tus?

Why tus?

Getting Started

ankitpokhrel / tus-php

🚀 A pure PHP server and client for the tus resumable upload protocol v1.0.0

TusPHP

Table of Contents

Installation

Creating a server to handle our requests

Handling upload using tus-php client

1. Create a tus-php client object

2. Initialize client with file metadata

3. Upload a chunk

Handling upload using tus-js-client

Partial Uploads

Final Words