courseDependenciesData.js

import {find} from 'lodash'

export default (courseSlug) =>
  find(
    [
      {
        slug: 'create-an-ecommerce-store-with-next-js-and-stripe-checkout-562c',
        dependencies: {
          react: '>= 17.0.1',
          next: '>=9.5.5',
        },
        topics: [
          'Starting a project with Create-Next-App',
          'Working with static and dynamic routes',
          'Managing product data in Stripe',
          'Securely managing secret keys',
          'Using the useReducer Hook and writing custom React Hooks for Cart functionality',
          'Add global state management with React Context',
          'Storing and retrieving data from localStorage',
          'Deploying with Vercel and GitHub',
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
        ],
        projects: [
          {
            label:
              'Create an eCommerce Store with Next.js and Stripe Checkout Workshop Repo',
            url: 'https://github.com/colbyfayock/space-jelly-store-workshop/',
          },
        ],
      },
      {
        slug: 'headless-wordpress-4a14',
        dependencies: {
          wordpress: '>=5.5.3',
          graphql: '>=15.0.0',
        },
        topics: [
          'Configure a WordPress instance using Local',
          'Install & customize WP Plugins',
          'Create custom post types',
          'Customize and interact with data via the REST API',
          'Expose a GraphQL API, and query for exactly what you want',
          'Generate fake WordPress data',
          'Add Comment functionality',
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'text',
            label: 'PHP familiarity helpful',
          },
        ],
      },
      {
        slug:
          'react-real-time-messaging-with-graphql-using-urql-and-onegraph-be5a',
        dependencies: {
          react: '>=16.13.1',
          urql: '>=1.9.7',
          graphql: '>=15.0.0',
        },
        topics: [
          'GraphQL endpoint configuration in OneGraph',
          'Using urql for GraphQL queries, mutations, and subscriptions',
          'Debugging network requests',
          'Managing authentication with React Context',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'graphql-query-language',
          },
          {
            type: 'egghead_playlist',
            label: 'Introduction to urql',
            slug: 'introduction-to-urql-a-react-graphql-client-faaa2bf5',
          },
          {
            type: 'egghead_course',
            slug: 'react-context-for-state-management',
          },
        ],
        projects: [
          {
            label: 'Build a conversation list with GraphQL Subscriptions',
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/react-real-time-messaging-with-graph-ql-using-urql-and-one-graph/exercises',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/react-real-time-messaging-with-graph-ql-using-urql-and-one-graph',
          },
        ],
      },
      {
        slug: 'scale-react-development-with-nx-4038',
        dependencies: {
          react: '>=16.13.1',
        },
        topics: [
          'Generating projects from scratch with Nx',
          'Add Storybook to a React app',
          'Creating & sharing libraries between apps',
          'Generating a backend API with a proxy for local development',
          "Exploring an app's relationships via the Dependency Graph visualizer",
          'Preparing for unit testing with Jest and e2e testing with Cypress',
        ],
        prerequisites: [
          {
            type: 'text',
            label: 'Command line familiarity',
          },
          {
            type: 'text',
            label: 'Node.js & npm installed',
          },
          {
            type: 'text',
            label: 'Familiarity with React & Express will be helpful',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/scale-react-development-with-nx',
          },
        ],
      },
      {
        slug: 'composing-closures-and-callbacks-in-javascript-1223',
        topics: [
          'Closures, Callbacks, and Composition',
          'Currying, Caching, and Creating operators',
          'Creating custom React Hooks',
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/composing-closures-and-callbacks-in-javascript',
          },
        ],
      },
      {
        slug: 'build-maps-with-react-leaflet',
        dependencies: {
          react: '>=16.13.1',
          leaflet: '>=1.6.0',
        },
        topics: [
          "Using Mapbox to style the map's appearance",
          'Store location data in GeoJSON documents',
          'Customize map markers & tooltips to display metadata',
          'useEffect and useRef React Hooks',
          'Dynamic location-based data',
          'Event handling',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
        ],
        projects: [
          {
            label: 'Build a Map with React Leaflet workshop repo',
            url: 'https://github.com/colbyfayock/launchtime-workshop',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/building-maps-with-react-leaflet',
          },
        ],
      },
      {
        slug:
          'eject-create-react-app-and-use-gatsby-for-advanced-react-app-development',
        dependencies: {
          gatsby: '^2.22.8',
        },
        topics: [
          'Starting a Gatsby Project from scratch',
          'Programmatic page creation',
          'Static and Dynamic routing',
          'Building with page templates',
          'Passing data via pageContext',
          'Handling protected routes with mock authentication',
          'Adding & configuring Gatsby plugins',
          "React's useState and useEffect hooks",
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
        ],
        projects: [
          {
            label: 'Extract pages from CRA to Gatsby',
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/eject-create-react-app-and-use-gatsby-for-advanced-react-app-development/excercises/',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/eject-create-react-app-and-use-gatsby-for-advanced-react-app-development',
          },
        ],
      },
      {
        slug: 'build-an-app-with-the-aws-cloud-development-kit',
        dependencies: {
          'aws-cdk': '>=1.32.2',
        },
        topics: [
          'Execute AWS Lambda functions locally',
          'Create Amazon S3 buckets with AWS CDK',
          'Attach an API Gateway to a Lambda function',
          'Add & Remove DynamoDB data with Lambda functions',
          'Manage permissions in the cloud',
          'Connect a frontend React app to AWS CDK infrastructure',
          'Deploy a finished app to S3',
          'Destroy a CDK stack',
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'egghead_lesson',
            label: 'Create an AWS IAM User with Programmatic Access',
            slug:
              'egghead-create-an-admin-user-with-iam-and-configure-aws-cli-to-enable-programmatic-access-to-aws',
          },
          {
            type: 'egghead_playlist',
            label: 'AWS Billing and Cost Management',
            slug:
              'use-aws-billing-cost-management-dashboard-to-keep-your-aws-bill-to-minimum-ff0f',
          },
          {
            type: 'egghead_playlist',
            label: 'Learn AWS Lambda from Scratch',
            slug: 'learn-aws-lambda-from-scratch-d29d',
          },
          {
            type: 'egghead_playlist',
            label: 'Learn AWS Serverless Application Model (SAM)',
            slug:
              'learn-aws-serverless-application-model-aws-sam-framework-from-scratch-baf9',
          },
          {
            type: 'egghead_playlist',
            label: 'Intro to DynamoDB',
            slug: 'intro-to-dynamodb-f35a',
          },
        ],
        projects: [
          {
            label: 'Store user input on AWS using DynamoDB',
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/build-an-app-with-the-AWS-cloud-development-kit/exercises',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio/eggheadio-course-notes/tree/master/build-an-app-with-the-AWS-cloud-development-kit',
          },
        ],
      },
      {
        slug: 'advanced-sql-for-professional-developers',
        topics: [
          'CSV import & export',
          'Creating custom types',
          'Query Performance',
          'Transactions',
          'Pattern matching & regex',
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'sql-fundamentals',
          },
          {
            type: 'text',
            label: 'Familiarity with the CRUD actions in SQL',
          },
        ],
        projects: [
          {
            url:
              'https://github.com/eggheadio-projects/advanced-sql-for-professional-developers/tree/master/exercises',
          },
        ],
        notes: [
          {
            url:
              'https://github.com/eggheadio-projects/advanced-sql-for-professional-developers',
          },
        ],
      },
      {
        slug: 'the-beginner-s-guide-to-react',
        dependencies: {
          react: '>=16.12.0',
        },
        topics: [
          'what problems React can solve',
          'how React solves those problems under the hood',
          'what JSX is and how it translates to regular JavaScript function calls and objects',
          'manage state with hooks',
          'build forms',
        ],
      },
      {
        slug: 'thinking-reactively-with-rxjs',
        dependencies: {
          react: '>=16.9.0',
          rxjs: '>=6.5.3',
        },
        topics: [
          'RxJS Operators: flatMap, mapTo, merge, scan, and more',
          'Creating observables',
          'Building operators',
          'Converting written requirements to code',
          'Reactive problem solving',
        ],
        illustrator: {
          name: 'Kamil Khadeyev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'introduction-to-reactive-programming',
          },
          {
            type: 'egghead_course',
            slug: 'rxjs-beyond-the-basics-operators-in-depth',
          },
        ],
      },
      {
        slug: 'write-your-first-program-with-the-rust-language',
        dependencies: {
          rust: '>=1.40.0',
        },
        topics: [
          'Types',
          'Functions & Loops',
          'User Input',
          'Package management with `cargo`',
          'Pattern Matching',
          'Error Handling',
        ],
      },
      {
        slug: 'web-security-essentials-mitm-csrf-and-xss',
        dependencies: {
          express: '>=4.17.1',
          node: '>8.9.3',
        },
        topics: [
          'Session hijacking (and how to prevent it)',
          'Using Charles proxy to simulate various attacks',
          'Securely configuring cookies and protecting the data inside them',
          "Security rules of thumb such as 'defense in depth' and 'principle of least power'",
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'understand-the-basics-of-http',
          },
          {
            type: 'egghead_course',
            slug: 'getting-started-with-express-js',
          },
        ],
      },
      {
        slug: 'build-custom-cli-tooling-with-oclif-and-typescript',
        dependencies: {
          typescript: '>=3.3',
          node: '>=8.0.0',
        },
        topics: [
          'Create a Simple CLI',
          'Pass Args and flags to a CLI',
          'Set up testing for a CLI',
          'Add filesystem state to a CLI',
          'Scaffold boilerplates (e.g. templates)',
          'Polish the CLI with colors, spinners, etc.',
          'Spawn child processes so other CLIs can run',
          'Control logging & output from other processes',
        ],
        illustrator: {
          name: 'Aleksander Ageev',
        },
      },
      {
        slug: 'introduction-to-state-machines-using-xstate',
        dependencies: {
          xstate: '>=4.6.7',
        },
        topics: [
          'Build a simple machine for a piece of UI',
          'Build Hierarchical, Parallel, and, History state machines',
          'Identify the conditions & implement transition guards',
          'Trigger Actions on transition',
          'Handle infinite states when working with inputs',
          'Understand Activities',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'construct-sturdy-uis-with-xstate',
          },
        ],
      },
      {
        slug: 'develop-accessible-web-apps-with-react',
        dependencies: {
          react: '>=16.10.2',
        },
        topics: [
          'The impact of in-accessible web apps different disability groups',
          'How to access web sites in the same way impaired users do',
          'Inspecting & testing tools for accessibility',
          'Write accessible and extensible UI elements & widgets',
          'Iteratively refactor & test accessibility issues',
        ],
        illustrator: {
          name: 'Aleksander Ageev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
          {
            type: 'egghead_course',
            slug: 'simplify-react-apps-with-react-hooks',
          },
          {
            type: 'egghead_course',
            slug: 'start-building-accessible-web-applications-today',
          },
        ],
      },
      {
        slug: 'build-a-video-chat-app-with-twilio-and-gatsby',
        dependencies: {
          gatsby: '>=2.15.7',
          react: '>=16.9.0',
          twilio: '>=3.34.0',
        },
        topics: [
          'Create dynamic web apps using Gatsby',
          'Create and configure a Twilio account for enabling video calling',
          'Initialize and manage realtime interactions in a web app',
          'Handle complex application state using React Context and Hooks',
          'Write custom React Hooks to encapsulate application logic',
        ],
        illustrator: {
          name: 'Aleksander Ageev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
          {
            type: 'egghead_course',
            slug: 'simplify-react-apps-with-react-hooks',
          },
          {
            type: 'egghead_course',
            slug: 'build-a-blog-with-react-and-markdown-using-gatsby',
          },
          {
            type: 'egghead_course',
            slug: 'gatsby-theme-authoring',
          },
        ],
      },
      {
        slug: 'designing-graphql-schemas-99db',
        dependencies: {
          'apollo-server': '>=2.9.7',
        },
        topics: [
          'Naming conventions for fields, queries, mutations',
          'GraphQL Aliases',
          'Benefits of nullable fields',
          'Connection Specification',
          'Mutation Payload Design',
          'Nullable vs Non-nullable fields',
          'Evolving GraphQL Schemas',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'graphql-query-language',
          },
          {
            type: 'egghead_course',
            slug: 'graphql-data-in-react-with-apollo-client',
          },
        ],
      },
      {
        slug: 'build-an-app-with-react-suspense',
        dependencies: {
          react: '^0.0.0-experimental-b53ea6ca0',
        },
        topics: [
          'Understand the Suspense component',
          'Set up ErrorBoundary where conditions aren’t met',
          'Devise strategies to resolve different children',
          'Import & use CreateResource to prepare for Suspense',
          'Understand concurrent mode',
          'Extract components into modules',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
          {
            type: 'egghead_course',
            slug: 'simplify-react-apps-with-react-hooks',
          },
          {
            type: 'egghead_course',
            slug: 'advanced-react-component-patterns',
          },
          {
            type: 'egghead_course',
            slug: 'reusable-state-and-effects-with-react-hooks',
          },
        ],
      },
      {
        slug: 'a-journey-with-vue-router',
        dependencies: {
          vue: '>=2.5.22',
          'vue-router': '>=3.1.3',
        },
        topics: [
          'Router installation and set up',
          'Route creation',
          'Router link creation',
          'Work with subroutes',
          'Creating a default route',
          'Access route metadata',
          'Create navigation guards',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'develop-basic-web-apps-with-vue-js',
          },
        ],
      },
      {
        slug: 'fix-common-git-mistakes',
        topics: [
          'Change commit messages',
          'Add or remove files from a commit',
          'How and when to stash changes',
          'What a "detached HEAD" is, and how to fix it',
          'Remove secrets from a codebase',
          'How to rewrite history',
        ],
        illustrator: {
          name: 'Aleksander Ageev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'practical-git-for-everyday-professional-use',
          },
          {
            type: 'egghead_course',
            slug: 'productive-git-for-developers',
          },
        ],
      },
      {
        slug: 'construct-sturdy-uis-with-xstate',
        dependencies: {
          xstate: '>=4.6.7',
          react: '>=16.9.0',
        },
        topics: [
          'Handling HTTP request state',
          'Blocking state transitions with guards',
          'Parallel state transitions',
          'Communicating between state machines in different components with the Actor Model',
          'Saving previous state history',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'introduction-to-state-machines-using-xstate',
          },
        ],
      },
      {
        slug: 'composable-gatsby-themes',
        dependencies: {
          gatsby: '>=2.16.5',
        },
        topics: [
          'Using yarn workspaces',
          'Creating theme starters',
          'Dealing with theme conflicts',
          'Styling & React Contexts',
          'Optimizing gatsby-config',
          'Advanced component shadowing techniques',
          'Lots more!',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'gatsby-theme-authoring',
          },
        ],
      },
      {
        slug: 'advanced-javascript-foundations',
        topics: [
          'Primitive Types: the What, How, and Why',
          'Reference Execution with the `this` Keyword',
          'Understanding Implicit vs Explicit Coercion',
          'How Prototypal Inheritance Works in JS',
          'Use the ES6 Class Keyword',
          'Understand Lexical vs. Dynamic Scope',
          'Create New Objects with the New Keyword',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'learn-es6-ecmascript-2015',
          },
        ],
      },
      {
        slug: 'use-suspense-to-simplify-your-async-ui',
        dependencies: {
          react: '0.0.0-experimental-b53ea6ca0',
        },
        topics: ['React Suspense', 'Async State'],
        goals: [
          'Simple data-fetching with Suspense',
          'Render as you fetch data',
          'useTransition for improved loading states',
          'Load images with Suspense Image',
          'Cache resources loaded through React Suspense',
          'Suspense with custom hooks',
          'Coordinate suspending components with SuspenseList',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'simplify-react-apps-with-react-hooks',
          },
          {
            type: 'egghead_course',
            slug: 'javascript-promises-in-depth',
          },
        ],
      },
      {
        slug: 'shareable-custom-hooks-in-react',
        dependencies: {
          react: '^16.8.6',
        },
        topics: ['Custom React Hooks', 'Test React Hooks', 'npm'],
        goals: [
          'Understanding `useState` and `useEffect`',
          'Writing a Custom Hook',
          'Extracting Hooks into their own modules',
          'Packaging a Hook',
          'Publishing a Hook to npm',
        ],
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
          {
            type: 'egghead_course',
            slug: 'reusable-state-and-effects-with-react-hooks',
          },
        ],
      },
      {
        slug: 'immutable-javascript-data-structures-with-immer',
        dependencies: {
          immer: '^4.0.0',
          react: '^16.8.6',
        },
        topics: [
          'Immutable State',
          'Structural sharing',
          'Currying',
          'Detect and distribute changes in data',
        ],
        goals: [
          'Deep state updating',
          'Rendering immutable data',
          'Leveraging structural sharing',
          "Update immutable state with React's `useReducer` hook",
          'Create & use patches',
        ],
        prerequisites: [
          {
            type: 'text',
            label: 'Basic knowledge of immutable principles',
          },
          {
            type: 'egghead_course',
            slug: 'learn-es6-ecmascript-2015',
          },
          {
            type: 'egghead_course',
            slug: 'simplify-react-apps-with-react-hooks',
          },
        ],
      },
      {
        slug: 'graphql-query-language',
        topics: [
          'Query, mutation, & subscription',
          'GraphiQL playground',
          'Schema',
          'Fragments',
          'Variables',
          'Input types, unions, interfaces, & return payloads',
          'Introspective Queries',
        ],
        goals: [
          'write any operation, top to bottom, with the GraphQL query language',
          'get data from an endpoint with a query',
          'change data with mutations',
          'subscribe to data changes',
          'reuse fields with fragments',
          'look at schema documentation in the GraphQL playground',
        ],
      },
      {
        slug: 'javascript-es2019-in-practice',
        topics: [
          'Flatten arrays',
          'Data/string manipulation',
          'Data structure management',
          'Use flat to map and filter at the same time',
          'Choose the most performant structure',
          'Clone objects',
          'What, when, and how to polyfill',
        ],
        prerequisites: [
          {
            type: 'text',
            label: 'Usage of common command line tools',
          },
          {
            type: 'egghead_course',
            slug: 'learn-es6-ecmascript-2015',
          },
          {
            type: 'egghead_course',
            slug: 'introduction-to-node-the-fundamentals',
          },
        ],
        goals: [
          'use every new feature approved for ES2019',
          'understand when to use optional catch binding',
          'update legacy projects for ES2019',
        ],
      },
      {
        slug:
          'build-content-rich-progressive-web-apps-with-gatsby-and-contentful',
        dependencies: {
          gatsby: '^2.5.7',
        },
        topics: [
          'Data Modeling with Contentful',
          'Starting a Gatsby project',
          'Using GraphQL to query data in Gatsby',
          'Deploying a static site with Netlify',
          'Set up automatic redeployment',
        ],
        illustrator: {
          name: 'Aleksander Ageev',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'build-a-blog-with-react-and-markdown-using-gatsby',
          },
          {
            type: 'text',
            label: 'Know React and GraphQL basics',
          },
        ],
        goals: [
          'plan your data types and their connections in Contentful',
          'build a Gatsby site',
          'use GraphQL to query data from Contentful',
          'deploy your site to Netlify',
          'redeploy your site when data changes',
        ],
      },
      {
        slug: 'gatsby-theme-authoring',
        dependencies: {
          gatsby: '>=2.13.1',
        },
      },
      {
        slug: 'vue-and-socket-io-for-real-time-communication',
        dependencies: {
          vue: '^2.5.21',
          'socket.io': '^2.2.0',
        },
        topics: [
          'Configuring a client for realtime communication',
          'Broadcasting messages to one or many clients',
          'Filtering messaging while targeting specific clients',
          'Identifying and grouping clients',
          'Triggering side effects',
          'Client-client, client-server, and server-server communication',
        ],
        prerequisites: [
          {
            type: 'text',
            label: 'Some basic understanding of JavaScript, HTML, and CSS',
          },
          {
            type: 'text',
            label:
              'Familiarity with Vue, npm and node, and express servers is recommended',
          },
          {
            type: 'text',
            label:
              'No previous experience with realtime communication libraries needed!',
          },
        ],
        goals: [
          'Add basic real-time functionality to any application',
          'Broadcast a message to one or many connected clients',
          'Configure socket.io with node.js',
          'Connect to a socket in vue components',
        ],
      },
      {
        slug: 'vr-applications-using-react-360',
        dependencies: {
          react: '^16.3.2',
          'react-360': '^1.1.0',
        },
        topics: [
          'React concepts: components, props, state',
          'Surfaces',
          'Image distortion',
          'Runtime',
          'Models & Entities',
          'Events & handlers',
          'Native modules',
          'Animations',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'egghead_course',
            slug: 'the-beginner-s-guide-to-react',
          },
          {
            type: 'text',
            label: 'Know the basics of React and how to use npm',
          },
          {
            type: 'text',
            label: 'Have some knowledge of JavaScript and CSS',
          },
          {
            type: 'text',
            label: 'No math or WebGL required!',
          },
        ],
        goals: [
          'Start and develop a React 360 app from scratch',
          'Add text and images using `<Text/>` and `<Image/>` components',
          'Use Surfaces to add 2D interfaces in a 3D space',
          'Add external 3D objects (e.g. from Google Poly) to React 360 apps',
          'Capture user interaction with events',
          'Add animation to elements',
        ],
      },
      {
        slug: 'test-production-ready-apps-with-cypress',
        dependencies: {
          cypress: '^3.1.5',
        },
        topics: [
          'Writing integration tests',
          'Selector best practices',
          'Seeding data into a database',
          'Mocking network requests',
          'Creating a mock backend',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'text',
            label: 'Basic knowledge of JavaScript, HTML, and CSS.',
          },
          {
            type: 'text',
            label: 'Basic understanding of client/server data transfer',
          },
          {
            type: 'text',
            label: 'Familiarity with DOM element selectors',
          },
        ],
        goals: [
          'Use Cypress to test all layers of your stack simultaneously',
          'Test the front and back ends of your application',
          'Ship apps that work like they’re supposed to, with no secret bugs for your users to discover',
        ],
      },
      {
        slug: 'sql-fundamentals',
        topics: [
          'Tables and table relationships',
          'Conditional selection',
          'Data integrity and data types',
          'Aggregate functions',
          'Subqueries',
          'And more...!',
        ],
        illustrator: {
          name: 'Maxime Bourgeois',
        },
        prerequisites: [
          {
            type: 'text',
            label: 'SQL beginners welcome!',
          },
          {
            type: 'text',
            label: 'Some command line and terminal experience will be helpful',
          },
        ],
      },
      {
        slug: 'react-navigation-for-native-mobile-applications',
        dependencies: {