@tailor-platform/sdk-plugin-app-shell 0.1.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2025 Tailor Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @tailor-platform/sdk-plugin-app-shell
+
+Tailor Platform SDK plugin that generates `tableMetadata` from TailorDB table definitions for use with `@tailor-platform/app-shell`'s `DataTable` component.
+
+## What it does
+
+`tableMetadata` bridges your TailorDB schema to the DataTable. It tells `inferColumns` how to render and filter each field — for example, which fields get a date picker, which get an enum dropdown (and with what options), and which are numeric. Without it, you would need to declare all of this manually per column.
+
+The metadata is generated at SDK generate time from your TailorDB table definitions, so it stays in sync with your schema automatically.
+
+## Installation
+
+```sh
+pnpm add -D @tailor-platform/sdk-plugin-app-shell
+```
+
+## Setup
+
+Supports `@tailor-platform/sdk` `^1 || ^2`. The examples below use the v2 CLI and TailorDB table API.
+
+Register the plugin in `tailor.config.ts`:
+
+```ts
+import { definePlugins } from "@tailor-platform/sdk";
+import { appShellPlugin } from "@tailor-platform/sdk-plugin-app-shell";
+
+export const plugins = definePlugins(
+  appShellPlugin({
+    dataTable: {
+      metadataOutputPath: "src/generated/app-shell-datatable.generated.ts",
+    },
+  }),
+);
+```
+
+Then run `tailor generate` to produce the metadata file.
+
+## Usage
+
+Pass `tableMetadata` to `inferColumns` to get type-safe column definitions with filter editors automatically configured:
+
+```ts
+import { tableMetadata } from "@/generated/app-shell-datatable.generated";
+import { createColumnHelper } from "@tailor-platform/app-shell";
+
+const { column, inferColumns } = createColumnHelper<Order>();
+const infer = inferColumns(tableMetadata.order);
+
+const columns = [
+  column(infer("title")), // string column    → text filter
+  column(infer("status")), // enum column      → dropdown filter with generated values
+  column(infer("createdAt")), // datetime column  → date picker filter
+];
+```
+
+You can still override per-column defaults when needed. For example, pass a non-empty `filter.operators` allowlist to narrow the built-in DataTable filter UI for one field:
+
+```ts
+const columns = [column(infer("title", { filter: { operators: ["contains", "eq"] } }))];
+```
+
+`operators` only affects the built-in DataTable filter UI. Programmatic `CollectionControl.addFilter(...)`, URL state, and saved/persisted filters still use the broader backend operator set.
+
+For full `DataTable` usage, see [`@tailor-platform/app-shell`](../core/README.md).

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { Plugin } from "@tailor-platform/sdk";
+//#region src/plugin.d.ts
+/**
+ * Options for the AppShell plugin.
+ */
+interface AppShellPluginOptions {
+  dataTable?: {
+    /**
+     * Output file path for generated DataTable metadata (relative to project root).
+     * @default "app-shell-datatable.generated.ts"
+     */
+    metadataOutputPath?: string;
+  };
+}
+declare function appShellPlugin(options?: AppShellPluginOptions): Plugin<void, AppShellPluginOptions>;
+//#endregion
+export { type AppShellPluginOptions, appShellPlugin };

package/dist/index.mjs

@@ -0,0 +1,119 @@
+//#region src/plugin.ts
+/**
+* Map TailorDB field type to AppShell FieldType.
+*/
+function mapFieldType(tailorType, isArray) {
+	const mappedType = {
+		string: "string",
+		integer: "number",
+		float: "number",
+		decimal: "number",
+		boolean: "boolean",
+		uuid: "uuid",
+		datetime: "datetime",
+		date: "date",
+		time: "time",
+		enum: "enum",
+		nested: "nested",
+		file: "file"
+	}[tailorType] ?? "string";
+	if (isArray) return {
+		type: "array",
+		arrayItemType: mappedType
+	};
+	return { type: mappedType };
+}
+/**
+* Convert PascalCase to camelCase.
+*/
+function toCamelCase(str) {
+	return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function appShellPlugin(options = {}) {
+	const { metadataOutputPath = "app-shell-datatable.generated.ts" } = options.dataTable ?? {};
+	return {
+		id: "app-shell-metadata",
+		description: "Generates table metadata for AppShell DataTable (inferColumns, createColumnHelper)",
+		pluginConfig: options,
+		onTailorDBReady(context) {
+			const metadataMap = {};
+			for (const ns of context.tailordb) {
+				const schemaEntries = "tables" in ns ? ns.tables : ns.types;
+				for (const type of Object.values(schemaEntries)) {
+					const fields = [];
+					const relations = [];
+					for (const [fieldName, field] of Object.entries(type.fields)) {
+						const config = field.config;
+						const { type: fieldType, arrayItemType } = mapFieldType(config.type, config.array);
+						let fieldRelation;
+						if (config.rawRelation) {
+							const raw = config.rawRelation;
+							if ((raw.type === "manyToOne" || raw.type === "n-1" || raw.type === "N-1" || raw.type === "oneToOne" || raw.type === "1-1") && raw.toward) {
+								const targetName = raw.toward.table ?? raw.toward.type;
+								if (targetName) {
+									const targetTableName = toCamelCase(targetName);
+									fieldRelation = {
+										fieldName: raw.toward.as ?? targetTableName,
+										targetTable: targetTableName
+									};
+								}
+							}
+						}
+						const enumValues = config.allowedValues && config.allowedValues.length > 0 ? config.allowedValues.map((v) => typeof v === "string" ? v : v.value) : void 0;
+						const fieldMetadata = {
+							name: fieldName,
+							type: fieldType,
+							required: config.required ?? false,
+							...config.description && { description: config.description },
+							...enumValues && { enumValues },
+							...arrayItemType && { arrayItemType },
+							...fieldRelation && { relation: fieldRelation }
+						};
+						fields.push(fieldMetadata);
+					}
+					for (const [relName, rel] of Object.entries(type.forwardRelationships ?? {})) {
+						const fkField = type.fields[rel.sourceField];
+						const isOneToOne = fkField?.config.rawRelation?.type === "1-1" || fkField?.config.rawRelation?.type === "oneToOne";
+						relations.push({
+							fieldName: relName,
+							targetTable: toCamelCase(rel.targetType),
+							relationType: isOneToOne ? "oneToOne" : "manyToOne",
+							foreignKeyField: rel.sourceField
+						});
+					}
+					for (const [relName, rel] of Object.entries(type.backwardRelationships ?? {})) relations.push({
+						fieldName: relName,
+						targetTable: toCamelCase(rel.targetType),
+						relationType: "oneToMany",
+						foreignKeyField: rel.sourceField
+					});
+					const camelName = toCamelCase(type.name);
+					metadataMap[camelName] = {
+						name: camelName,
+						pluralForm: toCamelCase(type.pluralForm),
+						...type.description && { description: type.description },
+						fields,
+						...relations.length > 0 && { relations }
+					};
+				}
+			}
+			const content = [
+				"// This file is auto-generated by app-shell-metadata plugin",
+				"// Do not edit manually",
+				"",
+				`export const tableMetadata = ${JSON.stringify(metadataMap, null, 2)} as const;`,
+				"",
+				`export const tableNames = ${JSON.stringify(Object.keys(metadataMap), null, 2)} as const;`,
+				"",
+				`export type TableName = (typeof tableNames)[number];`,
+				""
+			].join("\n");
+			return { files: [{
+				path: metadataOutputPath,
+				content
+			}] };
+		}
+	};
+}
+//#endregion
+export { appShellPlugin };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@tailor-platform/sdk-plugin-app-shell",
+  "version": "0.1.1",
+  "description": "Tailor Platform SDK plugins for AppShell (metadata generator)",
+  "keywords": [
+    "app-shell",
+    "metadata-generator",
+    "sdk-plugin",
+    "tailor-platform"
+  ],
+  "homepage": "https://github.com/tailor-platform/app-shell/tree/main/packages/sdk-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/tailor-platform"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tailor-platform/app-shell",
+    "directory": "packages/sdk-plugin"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@tailor-platform/sdk": "^2.7.0",
+    "@tailor-platform/sdk-v1": "npm:@tailor-platform/sdk@1.85.1",
+    "oxlint": "^1.64.0",
+    "tsdown": "^0.22.14",
+    "typescript": "5.9.3",
+    "vitest": "^4.1.10",
+    "@tailor-platform/app-shell": "1.13.0"
+  },
+  "peerDependencies": {
+    "@tailor-platform/sdk": "^1.0.0 || ^2.0.0"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "lint": "oxlint -c .oxlintrc.jsonc",
+    "test": "vitest run",
+    "type-check": "tsc --incremental"
+  }
+}