Skip to content

forcedotcom/sf-skills / plugins/builder/experience-lwc/skills/experience-lwc-generate

experience-lwc-generate

Unverified

Lightning Web Components with PICKLES methodology and 165-point scoring. Use this skill when the user creates or edits LWC components, builds wire service patterns, or writes Jest tests for LWC. TRIGGER when: user creates/edits LWC components, touches lwc/**/*.js, .html, .css, .js-meta.xml files, or asks about wire service, SLDS, or Jest LWC tests. DO NOT TRIGGER when: Apex classes (use platform-apex-generate), Aura components, or Visualforce.

FileKindSize
README.mdmarkdown4.1 KB
SKILL.mdskill md9.6 KB
assets/apex-controller/LwcController.clsother12.0 KB
assets/basic-component/basicComponent.cssother1.5 KB
assets/basic-component/basicComponent.htmlother4.5 KB
assets/basic-component/basicComponent.jsscript7.3 KB
assets/basic-component/basicComponent.js-meta.xmlconfig4.5 KB
assets/datatable-component/datatableComponent.htmlother4.1 KB
assets/datatable-component/datatableComponent.jsscript13.1 KB
assets/flow-screen-component/flowScreenComponent.cssother1.7 KB
assets/flow-screen-component/flowScreenComponent.htmlother7.1 KB
assets/flow-screen-component/flowScreenComponent.jsscript13.9 KB
assets/flow-screen-component/flowScreenComponent.js-meta.xmlconfig3.9 KB
assets/form-component/formComponent.htmlother6.4 KB
assets/form-component/formComponent.jsscript11.3 KB
assets/graphql-component/graphqlComponent.htmlother4.8 KB
assets/graphql-component/graphqlComponent.jsscript10.7 KB
assets/jest-test/componentName.test.js.exampleother15.6 KB
assets/message-channel/RecordSelected.messageChannel-meta.xmlconfig2.4 KB
assets/message-channel/lmsPublisher.jsscript3.8 KB
assets/message-channel/lmsSubscriber.jsscript7.0 KB
assets/modal-component/modalComponent.htmlother3.2 KB
assets/modal-component/modalComponent.jsscript5.5 KB
assets/record-picker/recordPicker.htmlother2.0 KB
assets/record-picker/recordPicker.jsscript5.4 KB
assets/state-store/store.jsscript9.1 KB
assets/typescript-component/typescriptComponent.cssother1.3 KB
assets/typescript-component/typescriptComponent.htmlother4.3 KB
assets/typescript-component/typescriptComponent.js-meta.xmlconfig2.4 KB
assets/typescript-component/typescriptComponent.test.ts.exampleother13.6 KB
assets/typescript-component/typescriptComponent.tsscript11.7 KB
assets/workspace-api/workspaceComponent.htmlother3.4 KB
assets/workspace-api/workspaceComponent.jsscript8.0 KB
references/accessibility-guide.mdmarkdown22.3 KB
references/advanced-features.mdmarkdown2.8 KB
references/async-notification-patterns.mdmarkdown19.7 KB
references/cli-commands.mdmarkdown12.6 KB
references/component-patterns.mdmarkdown44.5 KB
references/flow-integration-guide.mdmarkdown19.0 KB
references/jest-testing.mdmarkdown25.3 KB
references/lms-guide.mdmarkdown21.9 KB
references/lwc-best-practices.mdmarkdown36.3 KB
references/performance-guide.mdmarkdown20.3 KB
references/scoring-and-testing.mdmarkdown3.8 KB
references/slds-blueprints.jsonconfig781.3 KB
references/slds-design-guide.mdmarkdown10.7 KB
references/state-management.mdmarkdown19.9 KB
references/template-anti-patterns.mdmarkdown20.1 KB
references/triangle-pattern.mdmarkdown12.5 KB
scripts/local-dev-preview.shscript1.1 KB
scripts/lwc-lsp-validate.pyscript8.6 KB
scripts/post-tool-validate.pyscript14.7 KB
scripts/slds_data/deprecated_patterns.jsonconfig3.4 KB
scripts/slds_data/styling_hooks.jsonconfig2.9 KB
scripts/slds_data/valid_slds_classes.jsonconfig7.4 KB
scripts/slds_linter_wrapper.pyscript8.9 KB
scripts/slds_rules/__init__.pyscript593 B
scripts/template_validator.pyscript13.5 KB
scripts/validate_slds.pyscript26.5 KB

assets/graphql-component/graphqlComponent.js

View on GitHub
/**
 * GraphQL Component Template
 *
 * Demonstrates GraphQL patterns for LWC with:
 * - GraphQL query definition using gql tagged template
 * - GraphQL mutations (Create, Update, Delete) - Spring '26 GA
 * - Cursor-based pagination
 * - Reactive variables
 * - Error handling
 * - Data transformation
 *
 * Module: lightning/graphql supersedes lightning/uiGraphQLApi
 * Requires: API 66.0+ for mutations (GA in Spring '26)
 *
 * @see https://developer.salesforce.com/docs/platform/lwc/guide/data-graphql.html
 */
import { LightningElement, wire, track } from 'lwc';
import { gql, graphql, refreshGraphQL, executeMutation } from 'lightning/graphql';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';

// ═══════════════════════════════════════════════════════════════════════════
// GRAPHQL QUERY
// ═══════════════════════════════════════════════════════════════════════════
const CONTACTS_QUERY = gql`
    query ContactsWithAccount($first: Int!, $after: String, $orderBy: ContactOrderByInput) {
        uiapi {
            query {
                Contact(first: $first, after: $after, orderBy: $orderBy) {
                    edges {
                        node {
                            Id
                            Name { value }
                            Email { value }
                            Phone { value }
                            Title { value }
                            Account {
                                Id
                                Name { value }
                            }
                        }
                        cursor
                    }
                    pageInfo {
                        hasNextPage
                        hasPreviousPage
                        endCursor
                        startCursor
                    }
                    totalCount
                }
            }
        }
    }
`;

// ═══════════════════════════════════════════════════════════════════════════
// GRAPHQL MUTATIONS (Spring '26 - API 66.0+)
// ═══════════════════════════════════════════════════════════════════════════

/**
 * Create a new Contact record
 * Returns the newly created record fields
 */
const CREATE_CONTACT = gql`
    mutation CreateContact($firstName: String, $lastName: String!, $email: String, $accountId: ID) {
        uiapi {
            ContactCreate(input: {
                Contact: {
                    FirstName: $firstName
                    LastName: $lastName
                    Email: $email
                    AccountId: $accountId
                }
            }) {
                Record {
                    Id
                    Name { value }
                    Email { value }
                }
            }
        }
    }
`;

/**
 * Update an existing Contact record
 * Note: Cannot query fields in update response
 */
const UPDATE_CONTACT = gql`
    mutation UpdateContact($id: ID!, $firstName: String, $lastName: String, $email: String) {
        uiapi {
            ContactUpdate(input: {
                Contact: {
                    Id: $id
                    FirstName: $firstName
                    LastName: $lastName
                    Email: $email
                }
            }) {
                Record {
                    Id
                }
            }
        }
    }
`;

/**
 * Delete a Contact record
 */
const DELETE_CONTACT = gql`
    mutation DeleteContact($id: ID!) {
        uiapi {
            ContactDelete(input: { Contact: { Id: $id } }) {
                Id
            }
        }
    }
`;

export default class GraphqlComponent extends LightningElement {
    // Data state
    @track contacts = [];
    pageInfo;
    totalCount = 0;
    error;
    isLoading = true;

    // Pagination state
    _pageSize = 10;
    _cursor = null;

    // Store the wire result for refresh
    _wiredResult;

    /**
     * Wire the GraphQL query with reactive variables
     * Variables are recalculated whenever queryVariables getter returns new values
     */
    @wire(graphql, {
        query: CONTACTS_QUERY,
        variables: '$queryVariables'
    })
    wiredContacts(result) {
        this._wiredResult = result;
        const { data, error } = result;

        this.isLoading = false;

        if (data) {
            const queryResult = data.uiapi.query.Contact;

            // Transform GraphQL response to flat structure
            this.contacts = queryResult.edges.map(edge => ({
                id: edge.node.Id,
                name: edge.node.Name?.value,
                email: edge.node.Email?.value,
                phone: edge.node.Phone?.value,
                title: edge.node.Title?.value,
                accountId: edge.node.Account?.Id,
                accountName: edge.node.Account?.Name?.value,
                cursor: edge.cursor
            }));

            this.pageInfo = queryResult.pageInfo;
            this.totalCount = queryResult.totalCount;
            this.error = undefined;
        } else if (error) {
            this.error = this._reduceErrors(error);
            this.contacts = [];
        }
    }

    get queryVariables() {
        return {
            first: this._pageSize,
            after: this._cursor,
            orderBy: { Name: { order: 'ASC' } }
        };
    }

    get hasData() {
        return this.contacts.length > 0;
    }

    get hasNoData() {
        return !this.isLoading && !this.error && this.contacts.length === 0;
    }

    get hasNextPage() {
        return this.pageInfo?.hasNextPage;
    }

    get currentPageInfo() {
        return `Showing ${this.contacts.length} of ${this.totalCount} contacts`;
    }

    handleLoadMore() {
        if (this.hasNextPage) {
            this.isLoading = true;
            this._cursor = this.pageInfo.endCursor;
        }
    }

    handleRefresh() {
        this.isLoading = true;
        this._cursor = null;
        refreshGraphQL(this._wiredResult);
    }

    handleRowClick(event) {
        const contactId = event.currentTarget.dataset.id;
        this.dispatchEvent(new CustomEvent('contactselected', {
            detail: { contactId },
            bubbles: true,
            composed: true
        }));
    }

    _reduceErrors(errors) {
        if (!Array.isArray(errors)) {
            errors = [errors];
        }
        return errors
            .filter(error => !!error)
            .map(error => {
                if (typeof error === 'string') return error;
                if (error.body?.message) return error.body.message;
                if (error.message) return error.message;
                return 'Unknown error';
            })
            .join('; ');
    }

    // ═══════════════════════════════════════════════════════════════════════
    // MUTATION METHODS (Spring '26 - API 66.0+)
    // ═══════════════════════════════════════════════════════════════════════

    /**
     * Create a new Contact via GraphQL mutation
     * @param {Object} contactData - { firstName, lastName, email, accountId }
     * @returns {Promise<Object>} - Created record
     */
    async createContact(contactData) {
        try {
            const result = await executeMutation(CREATE_CONTACT, {
                variables: {
                    firstName: contactData.firstName || null,
                    lastName: contactData.lastName,
                    email: contactData.email || null,
                    accountId: contactData.accountId || null
                }
            });

            const newRecord = result.data.uiapi.ContactCreate.Record;
            this._showToast('Success', `Contact "${newRecord.Name.value}" created`, 'success');

            // Refresh the query to show new record
            await refreshGraphQL(this._wiredResult);

            return newRecord;
        } catch (error) {
            this._handleMutationError(error);
            throw error;
        }
    }

    /**
     * Update an existing Contact via GraphQL mutation
     * @param {String} contactId - ID of contact to update
     * @param {Object} updates - { firstName, lastName, email }
     * @returns {Promise<Object>} - Updated record ID
     */
    async updateContact(contactId, updates) {
        try {
            const result = await executeMutation(UPDATE_CONTACT, {
                variables: {
                    id: contactId,
                    firstName: updates.firstName,
                    lastName: updates.lastName,
                    email: updates.email
                }
            });

            this._showToast('Success', 'Contact updated successfully', 'success');

            // Refresh the query to show updated data
            await refreshGraphQL(this._wiredResult);

            return result.data.uiapi.ContactUpdate.Record;
        } catch (error) {
            this._handleMutationError(error);
            throw error;
        }
    }

    /**
     * Delete a Contact via GraphQL mutation
     * @param {String} contactId - ID of contact to delete
     */
    async deleteContact(contactId) {
        try {
            await executeMutation(DELETE_CONTACT, {
                variables: { id: contactId }
            });

            this._showToast('Success', 'Contact deleted successfully', 'success');

            // Refresh the query to remove deleted record
            await refreshGraphQL(this._wiredResult);
        } catch (error) {
            this._handleMutationError(error);
            throw error;
        }
    }

    /**
     * Handle mutation errors with proper GraphQL error parsing
     */
    _handleMutationError(error) {
        let message;
        if (error.graphQLErrors && error.graphQLErrors.length > 0) {
            message = error.graphQLErrors.map(e => e.message).join(', ');
        } else {
            message = error.message || 'An unknown error occurred';
        }
        this._showToast('Error', message, 'error');
    }

    /**
     * Display toast notification
     */
    _showToast(title, message, variant) {
        this.dispatchEvent(new ShowToastEvent({ title, message, variant }));
    }
}
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall