wehub-resource-sync
694 lines
25 KiB
TypeScript
694 lines
25 KiB
TypeScript
import * as sdk from '@botpress/sdk'
|
|
const { z } = sdk
|
|
|
|
type ActionDefinitions = NonNullable<sdk.IntegrationDefinition['actions']>
|
|
type ActionDef = ActionDefinitions[string]
|
|
|
|
const MAJOR_DIMENSION = ['ROWS', 'COLUMNS'] as const
|
|
export type MajorDimension = (typeof MAJOR_DIMENSION)[number]
|
|
|
|
const _sheetsValue = z
|
|
.string()
|
|
.title('Stringified value')
|
|
.describe('Represents the value of a single cell. This is a stringified number, string or boolean value')
|
|
|
|
const _commonFields = {
|
|
range: z.string().title('Range').placeholder("'Sheet name'!A1:F8"),
|
|
majorDimension: z.enum(MAJOR_DIMENSION).title('Major Dimension').default('ROWS'),
|
|
values: z
|
|
.array(
|
|
z
|
|
.array(_sheetsValue)
|
|
.title('Row or column')
|
|
.describe('Represents a major dimension (a row or column) of a values range')
|
|
)
|
|
.title('Values'),
|
|
} as const
|
|
|
|
const getValues = {
|
|
title: 'Get Values',
|
|
description: 'Returns the values of a range in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
range: _commonFields.range.describe('The A1 notation of the range to retrieve. (e.g. "Sheet1!A1:B2")'),
|
|
majorDimension: _commonFields.majorDimension
|
|
.optional()
|
|
.describe(
|
|
'If it equals "ROWS", then the values are returned as rows. If it equals "COLUMNS", then the values are returned as columns.'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
range: _commonFields.range.describe(
|
|
'The range the values cover, in A1 notation. This range indicates the entire requested range, even though the values will exclude trailing rows and columns. (e.g. "Sheet1!A1:B2")'
|
|
),
|
|
majorDimension: _commonFields.majorDimension.describe(
|
|
'If it equals "ROWS", then the values are returned in rows. If it equals "COLUMNS", then the values are returned in columns.'
|
|
),
|
|
values: _commonFields.values.describe(
|
|
'The data that was read. This is an array of arrays, the outer array representing all the data and each inner array representing a major dimension (a row or column). Each item in the inner array corresponds with one cell. (e.g. [["a", "b"], ["c", "d"]])'
|
|
),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const setValues = {
|
|
title: 'Set Values',
|
|
description: 'Sets values in a range in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
range: _commonFields.range.describe('The A1 notation of the range to update. (e.g. "Sheet1!A1:B2")'),
|
|
majorDimension: _commonFields.majorDimension
|
|
.optional()
|
|
.describe(
|
|
'If it equals "ROWS", then the values are inserted as rows. If it equals "COLUMNS", then the values are inserted as columns.'
|
|
),
|
|
values: _commonFields.values.describe(
|
|
'The values to write to the range. This is an array of arrays, where each inner array represents a major dimension (a row or column) of data. (e.g. [["a", "b"], ["c", "d"]])'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
spreadsheetId: z.string().title('Spreadsheet ID').describe('The spreadsheet the updates were applied to.'),
|
|
updatedRange: z
|
|
.string()
|
|
.title('Updated Range')
|
|
.describe('The range (in A1 notation) that updates were applied to.'),
|
|
updatedRows: z
|
|
.number()
|
|
.title('Updated Rows')
|
|
.describe('The number of rows where at least one cell in the row was updated.'),
|
|
updatedColumns: z
|
|
.number()
|
|
.title('Updated Columns')
|
|
.describe('The number of columns where at least one cell in the column was updated.'),
|
|
updatedCells: z.number().title('Updated Cells').describe('The number of cells updated.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const appendValues = {
|
|
title: 'Append Values',
|
|
description:
|
|
'Appends values to the spreadsheet. The input startColumn is used to search for existing data and find a "table" within that range. Values will be appended to the next row of the table, starting with the first column of the table.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
startColumn: z
|
|
.string()
|
|
.title('Start Column')
|
|
.describe(
|
|
'The start column letter(s) (e.g. "A", "B", "AA"). Used to identify the table in the sheet — data will be appended after the last row of the detected table.'
|
|
),
|
|
majorDimension: _commonFields.majorDimension
|
|
.optional()
|
|
.describe(
|
|
'If it equals "ROWS", then the values are inserted as rows. If it equals "COLUMNS", then the values are inserted as columns.'
|
|
),
|
|
values: _commonFields.values.describe(
|
|
'The values to write to the range. This is an array of arrays, where each inner array represents a major dimension (a row or column) of data. (e.g. [["a", "b"], ["c", "d"]])'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
spreadsheetId: z.string().title('Spreadsheet ID').describe('The spreadsheet the updates were applied to.'),
|
|
tableRange: z
|
|
.string()
|
|
.title('Table Range')
|
|
.describe(
|
|
'The range (in A1 notation) of the table that values are being appended to (before the values were appended). Empty if no table was found.'
|
|
),
|
|
updates: z
|
|
.object({
|
|
spreadsheetId: z.string().title('Spreadsheet ID').describe('The spreadsheet the updates were applied to.'),
|
|
updatedRange: z
|
|
.string()
|
|
.title('Updated Range')
|
|
.describe('The range (in A1 notation) that updates were applied to.'),
|
|
updatedRows: z
|
|
.number()
|
|
.title('Updated Rows')
|
|
.describe('The number of rows where at least one cell in the row was updated.'),
|
|
updatedColumns: z
|
|
.number()
|
|
.title('Updated Columns')
|
|
.describe('The number of columns where at least one cell in the column was updated.'),
|
|
updatedCells: z.number().title('Updated Cells').describe('The number of cells updated.'),
|
|
})
|
|
.title('Updates')
|
|
.describe('The updates that were applied to the spreadsheet.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const clearValues = {
|
|
title: 'Clear Values',
|
|
description:
|
|
'Clears values from a spreadsheet. Only values are cleared; all other properties of the cell (such as formatting, data validation, etc..) are kept.',
|
|
input: {
|
|
schema: z.object({
|
|
range: _commonFields.range.describe('The A1 notation of the range to clear. (e.g. "Sheet1!A1:B2")'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
spreadsheetId: z.string().title('Spreadsheet ID').describe('The spreadsheet the updates were applied to.'),
|
|
clearedRange: z.string().title('Cleared Range').describe('The range (in A1 notation) that was cleared.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const getInfoSpreadsheet = {
|
|
title: 'Get Info of a SpreadSheet',
|
|
description: 'Returns the properties and metadata of the specified spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
fields: z
|
|
.array(z.string().title('Field name').describe('The field to include in the response'))
|
|
.title('Fields')
|
|
.describe(
|
|
'The fields to include in the response when retrieving spreadsheet properties and metadata. This is a list of field names. (eg. spreadsheetId, properties.title, sheets.properties.sheetId, sheets.properties.title)'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
spreadsheetId: z
|
|
.union([z.string(), z.null()])
|
|
.title('Spreadsheet ID')
|
|
.describe('The unique identifier of the spreadsheet.')
|
|
.optional(),
|
|
spreadsheetUrl: z
|
|
.union([z.string(), z.null()])
|
|
.title('Spreadsheet URL')
|
|
.describe('The URL of the spreadsheet.')
|
|
.optional(),
|
|
dataSources: z
|
|
.array(z.any())
|
|
.describe('The data sources connected to the spreadsheet.')
|
|
.title('Data Sources')
|
|
.optional(),
|
|
dataSourceSchedules: z
|
|
.array(z.any())
|
|
.describe('The schedules of the data sources.')
|
|
.title('Data Source Schedules')
|
|
.optional(),
|
|
developerMetadata: z
|
|
.array(z.any())
|
|
.describe('The developer metadata associated with the spreadsheet.')
|
|
.title('Developer Metadata')
|
|
.optional(),
|
|
namedRanges: z
|
|
.array(z.any())
|
|
.describe('The named ranges defined in the spreadsheet.')
|
|
.title('Named Ranges')
|
|
.optional(),
|
|
properties: z.any().describe('The properties of the spreadsheet.').title('Properties').optional(),
|
|
sheets: z.array(z.any()).describe('The sheets present in the spreadsheet.').title('Sheets').optional(),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const addSheet = {
|
|
title: 'Add Sheet',
|
|
description: 'Adds a new sheet to the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
title: z.string().title('Title').describe('The title of the new sheet to add to the spreadsheet.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
spreadsheetId: z.string().title('Spreadsheet ID').describe('The spreadsheet ID of the new sheet.'),
|
|
newSheet: z
|
|
.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the new sheet.'),
|
|
title: z.string().title('Title').describe('The title of the new sheet.'),
|
|
index: z.number().title('Index').describe('The index of the new sheet within the spreadsheet.'),
|
|
isHidden: z.boolean().title('Is Hidden').describe('Whether the new sheet is hidden.'),
|
|
})
|
|
.title('New Sheet')
|
|
.describe('The new sheet that was added to the spreadsheet.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const deleteSheet = {
|
|
title: 'Delete Sheet',
|
|
description: 'Deletes a sheet from the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet to delete.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const renameSheet = {
|
|
title: 'Rename Sheet',
|
|
description: 'Renames a sheet in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet to rename.'),
|
|
newTitle: z.string().title('New Title').describe('The new title of the sheet.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const getAllSheetsInSpreadsheet = {
|
|
title: 'Get All Sheets in Spreadsheet',
|
|
description: 'Returns all sheets in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
sheets: z
|
|
.array(
|
|
z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet.'),
|
|
title: z.string().title('Title').describe('The name of the sheet.'),
|
|
index: z.number().title('Index').describe('The index of the sheet within the spreadsheet.'),
|
|
isHidden: z.boolean().title('Is Hidden').describe('Whether the sheet is hidden.'),
|
|
hasProtectedRanges: z
|
|
.boolean()
|
|
.title('Has Protected Ranges')
|
|
.describe('Whether the sheet has protected ranges.'),
|
|
isFullyProtected: z.boolean().title('Is Protected').describe('Whether the entire sheet is protected.'),
|
|
})
|
|
)
|
|
.title('Sheets')
|
|
.describe('The sheets present in the spreadsheet.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const setSheetVisibility = {
|
|
title: 'Set Sheet Visibility',
|
|
description: 'Sets the visibility of a sheet in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet to set visibility.'),
|
|
isHidden: z.boolean().title('Is Hidden').describe('Whether the sheet is hidden.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const moveSheetHorizontally = {
|
|
title: 'Move Sheet Horizontally',
|
|
description: 'Moves a sheet to a new index in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet to move.'),
|
|
newIndex: z.number().title('New Index').describe('The new index of the sheet within the spreadsheet.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const protectNamedRange = {
|
|
title: 'Protect Named Range',
|
|
description: 'Creates a protected range from a named range, preventing modification.',
|
|
input: {
|
|
schema: z.object({
|
|
namedRangeId: z.string().title('Named Range ID').describe('The ID of the named range to protect.'),
|
|
warningOnly: z
|
|
.boolean()
|
|
.title('Warning Only')
|
|
.optional()
|
|
.describe('Whether the protection displays a warning but still allows editing.'),
|
|
requestingUserCanEdit: z
|
|
.boolean()
|
|
.title('Requesting User Can Edit')
|
|
.optional()
|
|
.describe('Whether the user adding the protection can edit the protected range.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
protectedRangeId: z.number().title('Protected Range ID').describe('The ID of the new protected range.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const getNamedRanges = {
|
|
title: 'Get Named Ranges',
|
|
description: 'Returns all named ranges in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
namedRanges: z
|
|
.array(
|
|
z.object({
|
|
namedRangeId: z.string().title('Named Range ID').describe('The ID of the named range.'),
|
|
name: z.string().title('Name').describe('The name of the named range.'),
|
|
range: _commonFields.range.describe('The range of the named range in A1 notation. (e.g. "A1:B2")'),
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet the named range applies to.'),
|
|
})
|
|
)
|
|
.title('Named Ranges')
|
|
.describe('The named ranges defined in the spreadsheet.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const getProtectedRanges = {
|
|
title: 'Get Protected Ranges',
|
|
description: 'Returns all protected ranges in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
protectedRanges: z
|
|
.array(
|
|
z.object({
|
|
protectedRangeId: z.number().title('Protected Range ID').describe('The ID of the protected range.'),
|
|
namedRangeId: z
|
|
.string()
|
|
.title('Named Range ID')
|
|
.describe('The ID of the named range, if the protected range is backed by a named range.'),
|
|
range: _commonFields.range.describe('The range of the protected range in A1 notation. (e.g. "A1:B2")'),
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet the protected range applies to.'),
|
|
description: z.string().title('Description').describe('The description of the protected range.'),
|
|
warningOnly: z
|
|
.boolean()
|
|
.title('Warning Only')
|
|
.describe('Whether the protection displays a warning but still allows editing.'),
|
|
requestingUserCanEdit: z
|
|
.boolean()
|
|
.title('Requesting User Can Edit')
|
|
.describe('Whether the user adding the protection can edit the protected range.'),
|
|
})
|
|
)
|
|
.title('Protected Ranges')
|
|
.describe('The protected ranges defined in the spreadsheet.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const unprotectRange = {
|
|
title: 'Unprotect Range',
|
|
description: 'Removes protection from a protected range in the spreadsheet.',
|
|
input: {
|
|
schema: z.object({
|
|
protectedRangeId: z.number().title('Protected Range ID').describe('The ID of the protected range to unprotect.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const createNamedRangeInSheet = {
|
|
title: 'Create Named Range in Sheet',
|
|
description: 'Creates a named range in a sheet.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetId: z.number().title('Sheet ID').describe('The ID of the sheet to create the named range in.'),
|
|
rangeName: z
|
|
.string()
|
|
.title('Name')
|
|
.describe(
|
|
'The name of the named range. Must follow naming rules: cannot contain spaces, cannot start with a number, and cannot conflict with standard cell references (e.g., "A1", "R1C1"). Names violating these rules will be considered invalid.'
|
|
),
|
|
rangeA1: _commonFields.range.describe(
|
|
'The A1 notation of the range to associate with the named range. (e.g. "Sheet1!A1:B2")'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
namedRangeId: z.string().title('Named Range ID').describe('The ID of the new named range.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const _rowSchema = z
|
|
.object({
|
|
rowIndex: z.number().title('Row Index').describe('The 1-based index of the row in the sheet.'),
|
|
values: z.array(z.string().title('Cell Value')).title('Values').describe('The cell values in the row.'),
|
|
})
|
|
.title('Row')
|
|
.describe('A row with its index and values.')
|
|
|
|
const findRows = {
|
|
title: 'Find Rows',
|
|
description:
|
|
'Search for rows where a specific column matches a value. Returns all matching rows with their indexes. Handles empty sheets and no matches gracefully by returning an empty array.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
searchColumn: z.string().title('Search Column').describe('The column letter to search in (e.g. "A", "B", "AA").'),
|
|
searchValue: z.string().title('Search Value').describe('The value to search for in the specified column.'),
|
|
dataRange: z
|
|
.string()
|
|
.title('Data Range')
|
|
.optional()
|
|
.describe(
|
|
'Optional A1 notation range to limit the search (e.g. "A1:F100"). If not provided, searches the entire sheet.'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
rows: z.array(_rowSchema).title('Matching Rows').describe('The rows that match the search criteria.'),
|
|
totalMatches: z.number().title('Total Matches').describe('The total number of matching rows found.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const findRow = {
|
|
title: 'Find Row (First Match)',
|
|
description:
|
|
'Search for the first row where a specific column matches a value. Returns the row data and its index, or null if no match is found.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
searchColumn: z.string().title('Search Column').describe('The column letter to search in (e.g. "A", "B", "AA").'),
|
|
searchValue: z.string().title('Search Value').describe('The value to search for in the specified column.'),
|
|
dataRange: z
|
|
.string()
|
|
.title('Data Range')
|
|
.optional()
|
|
.describe(
|
|
'Optional A1 notation range to limit the search (e.g. "A1:F100"). If not provided, searches the entire sheet.'
|
|
),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
found: z.boolean().title('Found').describe('Whether a matching row was found.'),
|
|
row: _rowSchema.nullable().describe('The first matching row, or null if not found.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const getRow = {
|
|
title: 'Get Row',
|
|
description: 'Fetch a specific row by its 1-based index. Provides direct row access without A1 notation math.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
rowIndex: z
|
|
.number()
|
|
.title('Row Index')
|
|
.describe('The 1-based row index to retrieve (e.g. 1 for the first row, 2 for the second row).'),
|
|
startColumn: z
|
|
.string()
|
|
.title('Start Column')
|
|
.optional()
|
|
.default('A')
|
|
.describe('The starting column letter (e.g. "A"). Defaults to "A".'),
|
|
endColumn: z
|
|
.string()
|
|
.title('End Column')
|
|
.optional()
|
|
.describe('The ending column letter (e.g. "Z"). If not provided, returns all columns with data.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
found: z.boolean().title('Found').describe('Whether the row exists and has data.'),
|
|
row: _rowSchema.nullable().describe('The row data, or null if the row is empty or does not exist.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const updateRow = {
|
|
title: 'Update Row',
|
|
description:
|
|
'Update a specific row by its 1-based index with a partial or complete set of values. Only the provided values are updated.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
rowIndex: z.number().title('Row Index').describe('The 1-based row index to update.'),
|
|
values: z
|
|
.array(z.string().title('Cell Value'))
|
|
.title('Values')
|
|
.describe('The values to write to the row, starting from the start column.'),
|
|
startColumn: z
|
|
.string()
|
|
.title('Start Column')
|
|
.optional()
|
|
.default('A')
|
|
.describe('The starting column letter for the update (e.g. "A"). Defaults to "A".'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
updatedRange: z.string().title('Updated Range').describe('The range (in A1 notation) that was updated.'),
|
|
updatedCells: z.number().title('Updated Cells').describe('The number of cells updated.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const insertRowAtIndex = {
|
|
title: 'Insert Row at Index',
|
|
description: 'Insert a new row at a specific 1-based index. Existing rows at and below the index are shifted down.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
rowIndex: z.number().title('Row Index').describe('The 1-based index where the new row should be inserted.'),
|
|
values: z
|
|
.array(z.string().title('Cell Value'))
|
|
.title('Values')
|
|
.optional()
|
|
.describe('Optional values to populate the new row.'),
|
|
startColumn: z
|
|
.string()
|
|
.title('Start Column')
|
|
.optional()
|
|
.default('A')
|
|
.describe('The starting column letter for the values (e.g. "A"). Defaults to "A".'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
insertedRowIndex: z.number().title('Inserted Row Index').describe('The 1-based index of the newly inserted row.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const deleteRows = {
|
|
title: 'Delete Rows',
|
|
description:
|
|
'Delete one or more rows by their 1-based indexes. Rows are deleted in reverse order to preserve indexes during deletion.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
rowIndexes: z
|
|
.array(z.number().title('Row Index'))
|
|
.title('Row Indexes')
|
|
.describe('The 1-based row indexes to delete.'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
deletedCount: z.number().title('Deleted Count').describe('The number of rows deleted.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
const upsertRow = {
|
|
title: 'Upsert Row',
|
|
description:
|
|
'Update a row if it exists (based on a key column match), or append a new row if no match is found. Useful for maintaining unique records.',
|
|
input: {
|
|
schema: z.object({
|
|
sheetName: z
|
|
.string()
|
|
.title('Sheet Name')
|
|
.optional()
|
|
.describe('The name of the sheet (e.g. "Sheet1"). If not provided, the first visible sheet is used.'),
|
|
keyColumn: z
|
|
.string()
|
|
.title('Key Column')
|
|
.describe('The column letter to use for matching (e.g. "A" for ID column).'),
|
|
keyValue: z.string().title('Key Value').describe('The value to match in the key column.'),
|
|
values: z.array(z.string().title('Cell Value')).title('Values').describe('The values to write to the row.'),
|
|
startColumn: z
|
|
.string()
|
|
.title('Start Column')
|
|
.optional()
|
|
.default('A')
|
|
.describe('The starting column letter for the values (e.g. "A"). Defaults to "A".'),
|
|
}),
|
|
},
|
|
output: {
|
|
schema: z.object({
|
|
action: z.enum(['updated', 'inserted']).title('Action').describe('Whether the row was updated or inserted.'),
|
|
rowIndex: z.number().title('Row Index').describe('The 1-based index of the affected row.'),
|
|
}),
|
|
},
|
|
} as const satisfies ActionDef
|
|
|
|
export const actions = {
|
|
addSheet,
|
|
appendValues,
|
|
clearValues,
|
|
createNamedRangeInSheet,
|
|
deleteRows,
|
|
deleteSheet,
|
|
findRow,
|
|
findRows,
|
|
getAllSheetsInSpreadsheet,
|
|
getInfoSpreadsheet,
|
|
getNamedRanges,
|
|
getProtectedRanges,
|
|
getRow,
|
|
getValues,
|
|
insertRowAtIndex,
|
|
moveSheetHorizontally,
|
|
protectNamedRange,
|
|
renameSheet,
|
|
setSheetVisibility,
|
|
unprotectRange,
|
|
updateRow,
|
|
upsertRow,
|
|
setValues,
|
|
} as const satisfies ActionDefinitions
|