@remix-run/data-table 0.2.1 → 0.3.0

package/src/lib/query.ts

@@ -143,6 +143,11 @@ type QueryResultMap<row extends Record<string, unknown>, loaded extends Record<s
   upsert: WriteResult | WriteRowResult<row>
 }
 
+/**
+ * Convenience alias for any {@link Query} regardless of its source, columns,
+ * row shape, loaded relations, or execution phase. Use this in helper APIs
+ * that accept a query but don't care about the specific generic parameters.
+ */
 export type AnyQuery = Query<any, any, any, any, any>
 
 type QuerySource<input extends AnyQuery> =
@@ -212,6 +217,17 @@ export const querySnapshot = Symbol('querySnapshot')
 
 declare const queryTypeBrand: unique symbol
 
+/**
+ * Type-safe query builder for `@remix-run/data-table` sources. Construct via
+ * {@link query} and chain calls (`select`, `where`, `orderBy`, etc.) to build
+ * up a plan; run it by `await`-ing on a runtime-bound query, or by passing an
+ * unbound one to a runtime.
+ *
+ * The five generic parameters track, in order: the source/table, the column
+ * type map, the projected row shape, any loaded relations, and the
+ * binding/execution-mode phase. Most consumers do not need to spell them out
+ * — `query(table)` infers everything.
+ */
 export class Query<
   source extends AnyQuerySource,
   columnTypes extends Record<string, unknown> = QuerySourceColumnTypes<source>,
@@ -684,6 +700,23 @@ export class Query<
   }
 }
 
+/**
+ * Begin a {@link Query} against a `@remix-run/data-table` source. The returned
+ * builder is in `'all'` execution mode and unbound; chain `select`, `where`,
+ * `orderBy`, etc. to refine the plan, and `await` it after binding it to a
+ * runtime to materialize results.
+ *
+ * @param table The table or source to query.
+ * @returns An unbound {@link Query} builder rooted at `table`.
+ *
+ * @example
+ * ```ts
+ * let activeUsers = await query(users)
+ *   .where({ status: 'active' })
+ *   .orderBy('createdAt', 'desc')
+ *   .select(['id', 'email'])
+ * ```
+ */
 export function query<
   tableName extends string,
   row extends Record<string, unknown>,

package/src/lib/sql-helpers.ts

@@ -1,31 +1,10 @@
-import type { DataManipulationOperation, DataMigrationOperation, TableRef } from './adapter.ts'
+import type { TableRef } from './adapter.ts'
 
 /**
  * Function used to quote SQL identifiers for a dialect.
  */
 export type QuoteIdentifier = (value: string) => string
 
-/**
- * Type guard that narrows an operation to the data-manipulation union.
- * @param operation Operation to inspect.
- * @returns `true` when the operation is a data-manipulation operation.
- */
-export function isDataManipulationOperation(
-  operation: DataManipulationOperation | DataMigrationOperation,
-): operation is DataManipulationOperation {
-  return (
-    operation.kind === 'select' ||
-    operation.kind === 'count' ||
-    operation.kind === 'exists' ||
-    operation.kind === 'insert' ||
-    operation.kind === 'insertMany' ||
-    operation.kind === 'update' ||
-    operation.kind === 'delete' ||
-    operation.kind === 'upsert' ||
-    operation.kind === 'raw'
-  )
-}
-
 /**
  * Normalizes an arbitrary join type string into `inner`, `left`, or `right`.
  * @param type Input join type.

package/src/migrations.ts

@@ -1,26 +1,16 @@
 export type {
-  AlterTableBuilder,
-  CreateMigrationInput,
-  Migration,
-  MigrationContext,
+  MigrateOptions,
+  MigrateResult,
   MigrationDescriptor,
   MigrationDirection,
   MigrationJournalRow,
-  MigrationSchema,
   MigrationRegistry,
   MigrationRunner,
   MigrationRunnerOptions,
   MigrationStatus,
   MigrationStatusEntry,
   MigrationTransactionMode,
-  MigrateOptions,
-  MigrateResult,
-  KeyColumns,
-  TableInput,
 } from './lib/migrations.ts'
-export { createMigration } from './lib/migrations.ts'
-export type { ColumnNamespace } from './lib/column.ts'
-export { ColumnBuilder, column } from './lib/column.ts'
 export { createMigrationRegistry } from './lib/migrations/registry.ts'
 export { createMigrationRunner } from './lib/migrations/runner.ts'
-export { parseMigrationFilename } from './lib/migrations/filename.ts'
+export { parseMigrationDirectoryName } from './lib/migrations/directory-name.ts'

package/src/sql-helpers.ts

@@ -1,7 +1,6 @@
 export type { QuoteIdentifier } from './lib/sql-helpers.ts'
 export {
   collectColumns,
-  isDataManipulationOperation,
   normalizeJoinType,
   quoteLiteral,
   quotePath,

package/dist/lib/migrations/filename.d.ts

@@ -1,12 +0,0 @@
-/**
- * Parses a migration filename into `{ id, name }`.
- *
- * Expected format: `YYYYMMDDHHmmss_name.(ts|js|mts|mjs|cts|cjs)`.
- * @param filename Migration file basename.
- * @returns Parsed migration id and name.
- */
-export declare function parseMigrationFilename(filename: string): {
-    id: string;
-    name: string;
-};
-//# sourceMappingURL=filename.d.ts.map

package/dist/lib/migrations/filename.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filename.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/filename.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAerF"}

package/dist/lib/migrations/filename.js

@@ -1,20 +0,0 @@
-const migrationFilenamePattern = /^(\d{14})_(.+)\.(?:m?ts|m?js|cts|cjs)$/;
-/**
- * Parses a migration filename into `{ id, name }`.
- *
- * Expected format: `YYYYMMDDHHmmss_name.(ts|js|mts|mjs|cts|cjs)`.
- * @param filename Migration file basename.
- * @returns Parsed migration id and name.
- */
-export function parseMigrationFilename(filename) {
-    let match = filename.match(migrationFilenamePattern);
-    if (!match) {
-        throw new Error('Invalid migration filename "' +
-            filename +
-            '". Expected format YYYYMMDDHHmmss_name.ts (or .js/.mts/.mjs/.cts/.cjs)');
-    }
-    return {
-        id: match[1],
-        name: match[2],
-    };
-}

package/dist/lib/migrations/helpers.d.ts

@@ -1,11 +0,0 @@
-import type { TableRef } from '../adapter.ts';
-import type { IndexColumns, KeyColumns } from '../migrations.ts';
-export declare function toTableRef(name: string): TableRef;
-export declare function normalizeIndexColumns(columns: IndexColumns): string[];
-export declare function normalizeKeyColumns(columns: KeyColumns): string[];
-export declare function createPrimaryKeyName(table: TableRef): string;
-export declare function createUniqueName(table: TableRef, columns: string[]): string;
-export declare function createForeignKeyName(table: TableRef, columns: string[], references: TableRef, referenceColumns: string[]): string;
-export declare function createCheckName(table: TableRef, expression: string): string;
-export declare function createIndexName(table: TableRef, columns: string[]): string;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/migrations/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEhE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAWjD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,EAAE,CAErE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,EAAE,CAMjE;AAgDD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE3E;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,QAAQ,EACpB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAWR;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG3E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE1E"}

package/dist/lib/migrations/helpers.js

@@ -1,77 +0,0 @@
-export function toTableRef(name) {
-    let segments = name.split('.');
-    if (segments.length === 1) {
-        return { name };
-    }
-    return {
-        schema: segments[0],
-        name: segments.slice(1).join('.'),
-    };
-}
-export function normalizeIndexColumns(columns) {
-    return normalizeKeyColumns(columns);
-}
-export function normalizeKeyColumns(columns) {
-    if (Array.isArray(columns)) {
-        return [...columns];
-    }
-    return [columns];
-}
-function normalizeNamePart(value) {
-    let normalized = value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    if (normalized.length === 0) {
-        return 'item';
-    }
-    return normalized;
-}
-function tableNamePart(table) {
-    if (table.schema) {
-        return normalizeNamePart(table.schema + '_' + table.name);
-    }
-    return normalizeNamePart(table.name);
-}
-function hashString(value) {
-    let hash = 5381;
-    for (let index = 0; index < value.length; index++) {
-        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
-    }
-    return hash >>> 0;
-}
-function withNameLimit(name) {
-    let limit = 63;
-    if (name.length <= limit) {
-        return name;
-    }
-    let suffix = hashString(name).toString(36).padStart(8, '0').slice(0, 8);
-    return name.slice(0, limit - 9) + '_' + suffix;
-}
-function columnsNamePart(columns) {
-    return columns.map((column) => normalizeNamePart(column)).join('_');
-}
-export function createPrimaryKeyName(table) {
-    return withNameLimit(tableNamePart(table) + '_pk');
-}
-export function createUniqueName(table, columns) {
-    return withNameLimit(tableNamePart(table) + '_' + columnsNamePart(columns) + '_uq');
-}
-export function createForeignKeyName(table, columns, references, referenceColumns) {
-    let base = tableNamePart(table) +
-        '_' +
-        columnsNamePart(columns) +
-        '_' +
-        tableNamePart(references) +
-        '_' +
-        columnsNamePart(referenceColumns) +
-        '_fk';
-    return withNameLimit(base);
-}
-export function createCheckName(table, expression) {
-    let suffix = hashString(expression).toString(36);
-    return withNameLimit(tableNamePart(table) + '_chk_' + suffix);
-}
-export function createIndexName(table, columns) {
-    return withNameLimit(tableNamePart(table) + '_' + columnsNamePart(columns) + '_idx');
-}

package/dist/lib/migrations/schema-api.d.ts

@@ -1,7 +0,0 @@
-import type { Database } from '../database.ts';
-import type { DataMigrationOperation, TransactionToken } from '../adapter.ts';
-import type { MigrationSchema } from '../migrations.ts';
-export declare function createMigrationSchema(db: Database, emit: (operation: DataMigrationOperation) => Promise<void>, options?: {
-    transaction?: TransactionToken;
-}): MigrationSchema;
-//# sourceMappingURL=schema-api.d.ts.map

package/dist/lib/migrations/schema-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-api.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/schema-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAKV,sBAAsB,EAItB,gBAAgB,EAEjB,MAAM,eAAe,CAAA;AAItB,OAAO,KAAK,EAKV,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AA+PzB,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,CAAC,SAAS,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,EAC1D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAAE,GAC3C,eAAe,CAqIjB"}

package/dist/lib/migrations/schema-api.js

@@ -1,326 +0,0 @@
-import { rawSql } from "../sql.js";
-import { getTableColumnDefinitions, getTableName, getTablePrimaryKey } from "../table.js";
-import { ColumnBuilder } from "../column.js";
-import { createCheckName, createForeignKeyName, createIndexName, createPrimaryKeyName, createUniqueName, normalizeIndexColumns, normalizeKeyColumns, toTableRef, } from "./helpers.js";
-function asColumnDefinition(definition) {
-    if (definition instanceof ColumnBuilder) {
-        return definition.build();
-    }
-    return definition;
-}
-function asTableRef(value) {
-    if (typeof value === 'string') {
-        return toTableRef(value);
-    }
-    return toTableRef(getTableName(value));
-}
-function lowerTableForCreate(table) {
-    let tableRef = toTableRef(getTableName(table));
-    let sourceColumnDefinitions = getTableColumnDefinitions(table);
-    let columns = {};
-    let uniques = [];
-    let checks = [];
-    let foreignKeys = [];
-    for (let columnName in sourceColumnDefinitions) {
-        if (!Object.prototype.hasOwnProperty.call(sourceColumnDefinitions, columnName)) {
-            continue;
-        }
-        let sourceDefinition = sourceColumnDefinitions[columnName];
-        let columnDefinition = {
-            ...sourceDefinition,
-            checks: undefined,
-            references: undefined,
-            primaryKey: undefined,
-        };
-        let unique = sourceDefinition.unique;
-        if (unique) {
-            let uniqueName = typeof unique === 'object' && unique.name
-                ? unique.name
-                : createUniqueName(tableRef, [columnName]);
-            uniques.push({
-                name: uniqueName,
-                columns: [columnName],
-            });
-            columnDefinition.unique = undefined;
-        }
-        if (sourceDefinition.checks) {
-            for (let check of sourceDefinition.checks) {
-                checks.push({
-                    name: check.name || createCheckName(tableRef, check.expression),
-                    expression: check.expression,
-                });
-            }
-        }
-        if (sourceDefinition.references) {
-            let referenceColumns = [...sourceDefinition.references.columns];
-            let referencesTable = { ...sourceDefinition.references.table };
-            foreignKeys.push({
-                name: sourceDefinition.references.name ||
-                    createForeignKeyName(tableRef, [columnName], referencesTable, referenceColumns),
-                columns: [columnName],
-                references: {
-                    table: referencesTable,
-                    columns: referenceColumns,
-                },
-                onDelete: sourceDefinition.references.onDelete,
-                onUpdate: sourceDefinition.references.onUpdate,
-            });
-        }
-        columns[columnName] = columnDefinition;
-    }
-    let primaryKeyColumns = [...getTablePrimaryKey(table)];
-    let primaryKey;
-    if (primaryKeyColumns.length > 0) {
-        primaryKey = {
-            columns: primaryKeyColumns,
-            name: createPrimaryKeyName(tableRef),
-        };
-    }
-    return {
-        kind: 'createTable',
-        table: tableRef,
-        columns,
-        primaryKey,
-        uniques: uniques.length > 0 ? uniques : undefined,
-        checks: checks.length > 0 ? checks : undefined,
-        foreignKeys: foreignKeys.length > 0 ? foreignKeys : undefined,
-    };
-}
-class AlterTableBuilderRuntime {
-    alterChanges = [];
-    extraStatements = [];
-    table;
-    constructor(table) {
-        this.table = table;
-    }
-    addColumn(name, definition) {
-        this.alterChanges.push({
-            kind: 'addColumn',
-            column: name,
-            definition: asColumnDefinition(definition),
-        });
-    }
-    changeColumn(name, definition) {
-        this.alterChanges.push({
-            kind: 'changeColumn',
-            column: name,
-            definition: asColumnDefinition(definition),
-        });
-    }
-    renameColumn(from, to) {
-        this.alterChanges.push({ kind: 'renameColumn', from, to });
-    }
-    dropColumn(name, options) {
-        this.alterChanges.push({ kind: 'dropColumn', column: name, ifExists: options?.ifExists });
-    }
-    addPrimaryKey(columns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        this.alterChanges.push({
-            kind: 'addPrimaryKey',
-            constraint: {
-                columns: normalizedColumns,
-                name: options?.name ?? createPrimaryKeyName(this.table),
-            },
-        });
-    }
-    dropPrimaryKey(name) {
-        this.alterChanges.push({ kind: 'dropPrimaryKey', name });
-    }
-    addUnique(columns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        this.alterChanges.push({
-            kind: 'addUnique',
-            constraint: {
-                columns: normalizedColumns,
-                name: options?.name ?? createUniqueName(this.table, normalizedColumns),
-            },
-        });
-    }
-    dropUnique(name) {
-        this.alterChanges.push({ kind: 'dropUnique', name });
-    }
-    addForeignKey(columns, refTable, refColumns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
-        let referenceTable = asTableRef(refTable);
-        this.alterChanges.push({
-            kind: 'addForeignKey',
-            constraint: {
-                columns: normalizedColumns,
-                references: {
-                    table: referenceTable,
-                    columns: normalizedReferenceColumns,
-                },
-                name: options?.name ??
-                    createForeignKeyName(this.table, normalizedColumns, referenceTable, normalizedReferenceColumns),
-                onDelete: options?.onDelete,
-                onUpdate: options?.onUpdate,
-            },
-        });
-    }
-    dropForeignKey(name) {
-        this.alterChanges.push({ kind: 'dropForeignKey', name });
-    }
-    addCheck(expression, options) {
-        this.alterChanges.push({
-            kind: 'addCheck',
-            constraint: {
-                expression,
-                name: options?.name ?? createCheckName(this.table, expression),
-            },
-        });
-    }
-    dropCheck(name) {
-        this.alterChanges.push({ kind: 'dropCheck', name });
-    }
-    addIndex(columns, options) {
-        let normalizedColumns = normalizeIndexColumns(columns);
-        let { name, ifNotExists, ...indexOptions } = options ?? {};
-        this.extraStatements.push({
-            kind: 'createIndex',
-            index: {
-                table: this.table,
-                name: name ?? createIndexName(this.table, normalizedColumns),
-                columns: normalizedColumns,
-                ...indexOptions,
-            },
-            ifNotExists,
-        });
-    }
-    dropIndex(name) {
-        this.extraStatements.push({
-            kind: 'dropIndex',
-            table: this.table,
-            name,
-        });
-    }
-    comment(text) {
-        this.alterChanges.push({ kind: 'setTableComment', comment: text });
-    }
-}
-export function createMigrationSchema(db, emit, options) {
-    return {
-        async createTable(table, options) {
-            let operation = lowerTableForCreate(table);
-            operation.ifNotExists = options?.ifNotExists;
-            await emit(operation);
-        },
-        async alterTable(input, migrate, options) {
-            let tableRef = asTableRef(input);
-            let builder = new AlterTableBuilderRuntime(tableRef);
-            migrate(builder);
-            if (builder.alterChanges.length > 0) {
-                await emit({
-                    kind: 'alterTable',
-                    table: tableRef,
-                    changes: builder.alterChanges,
-                    ifExists: options?.ifExists,
-                });
-            }
-            for (let operation of builder.extraStatements) {
-                await emit(operation);
-            }
-        },
-        async renameTable(from, to) {
-            await emit({ kind: 'renameTable', from: asTableRef(from), to: toTableRef(to) });
-        },
-        async dropTable(table, options) {
-            await emit({
-                kind: 'dropTable',
-                table: asTableRef(table),
-                ifExists: options?.ifExists,
-                cascade: options?.cascade,
-            });
-        },
-        async createIndex(table, columns, options) {
-            let tableRef = asTableRef(table);
-            let normalizedColumns = normalizeIndexColumns(columns);
-            let { name, ifNotExists, ...indexOptions } = options ?? {};
-            await emit({
-                kind: 'createIndex',
-                index: {
-                    table: tableRef,
-                    name: name ?? createIndexName(tableRef, normalizedColumns),
-                    columns: normalizedColumns,
-                    ...indexOptions,
-                },
-                ifNotExists,
-            });
-        },
-        async dropIndex(table, name, options) {
-            await emit({
-                kind: 'dropIndex',
-                table: asTableRef(table),
-                name,
-                ifExists: options?.ifExists,
-            });
-        },
-        async renameIndex(table, from, to) {
-            await emit({
-                kind: 'renameIndex',
-                table: asTableRef(table),
-                from,
-                to,
-            });
-        },
-        async addForeignKey(table, columns, refTable, refColumns, options) {
-            let tableRef = asTableRef(table);
-            let normalizedColumns = normalizeKeyColumns(columns);
-            let referenceTable = asTableRef(refTable);
-            let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
-            await emit({
-                kind: 'addForeignKey',
-                table: tableRef,
-                constraint: {
-                    columns: normalizedColumns,
-                    references: {
-                        table: referenceTable,
-                        columns: normalizedReferenceColumns,
-                    },
-                    name: options?.name ??
-                        createForeignKeyName(tableRef, normalizedColumns, referenceTable, normalizedReferenceColumns),
-                    onDelete: options?.onDelete,
-                    onUpdate: options?.onUpdate,
-                },
-            });
-        },
-        async dropForeignKey(table, name) {
-            await emit({
-                kind: 'dropForeignKey',
-                table: asTableRef(table),
-                name,
-            });
-        },
-        async addCheck(table, expression, options) {
-            let tableRef = asTableRef(table);
-            await emit({
-                kind: 'addCheck',
-                table: tableRef,
-                constraint: {
-                    expression,
-                    name: options?.name ?? createCheckName(tableRef, expression),
-                },
-            });
-        },
-        async dropCheck(table, name) {
-            await emit({
-                kind: 'dropCheck',
-                table: asTableRef(table),
-                name,
-            });
-        },
-        async plan(sql) {
-            let statement = typeof sql === 'string' ? rawSql(sql) : sql;
-            await emit({
-                kind: 'raw',
-                sql: statement,
-            });
-        },
-        async hasTable(table) {
-            return db.adapter.hasTable(asTableRef(table), options?.transaction);
-        },
-        async hasColumn(table, columnName) {
-            return db.adapter.hasColumn(asTableRef(table), columnName, options?.transaction);
-        },
-    };
-}

package/src/lib/migrations/filename.ts

@@ -1,25 +0,0 @@
-const migrationFilenamePattern = /^(\d{14})_(.+)\.(?:m?ts|m?js|cts|cjs)$/
-
-/**
- * Parses a migration filename into `{ id, name }`.
- *
- * Expected format: `YYYYMMDDHHmmss_name.(ts|js|mts|mjs|cts|cjs)`.
- * @param filename Migration file basename.
- * @returns Parsed migration id and name.
- */
-export function parseMigrationFilename(filename: string): { id: string; name: string } {
-  let match = filename.match(migrationFilenamePattern)
-
-  if (!match) {
-    throw new Error(
-      'Invalid migration filename "' +
-        filename +
-        '". Expected format YYYYMMDDHHmmss_name.ts (or .js/.mts/.mjs/.cts/.cjs)',
-    )
-  }
-
-  return {
-    id: match[1],
-    name: match[2],
-  }
-}