@stonecrop/schema 0.11.0 → 0.11.2

package/dist/src/fieldtype.js

@@ -1,75 +0,0 @@
-import { z } from 'zod';
-/**
- * Stonecrop field types - the semantic type of the field.
- * These are consistent across forms and tables.
- * @public
- */
-export const StonecropFieldType = z
-    .enum([
-    'Data', // Short text, varchar
-    'Text', // Long text
-    'Int', // Integer
-    'Float', // Floating point (IEEE 754)
-    'Decimal', // Arbitrary precision decimal
-    'Check', // Boolean/checkbox
-    'Date', // Date only
-    'Time', // Time only
-    'Datetime', // Date and time
-    'Duration', // Time interval
-    'DateRange', // Date range
-    'JSON', // JSON data
-    'Code', // Code/source (with syntax highlighting)
-    'Link', // Reference to another doctype
-    'Doctype', // Child doctype (1:1 nested form or 1:many table via cardinality)
-    'Attach', // File attachment
-    'Currency', // Currency value
-    'Quantity', // Quantity with unit
-    'Select', // Dropdown selection
-])
-    .meta({
-    title: 'StonecropFieldType',
-    description: 'Semantic field types for Stonecrop doctypes, consistent across forms and tables',
-});
-/**
- * Mapping from StonecropFieldType to default Vue component.
- * Components can be overridden in the field definition.
- * @public
- */
-export const TYPE_MAP = {
-    // Text
-    Data: { component: 'ATextInput', fieldtype: 'Data' },
-    Text: { component: 'ATextInput', fieldtype: 'Text' },
-    // Numeric
-    Int: { component: 'ANumericInput', fieldtype: 'Int' },
-    Float: { component: 'ANumericInput', fieldtype: 'Float' },
-    Decimal: { component: 'ADecimalInput', fieldtype: 'Decimal' },
-    // Boolean
-    Check: { component: 'ACheckbox', fieldtype: 'Check' },
-    // Date/Time
-    Date: { component: 'ADate', fieldtype: 'Date' },
-    Time: { component: 'ATimeInput', fieldtype: 'Time' },
-    Datetime: { component: 'ADatetimePicker', fieldtype: 'Datetime' },
-    Duration: { component: 'ADurationInput', fieldtype: 'Duration' },
-    DateRange: { component: 'ADateRangePicker', fieldtype: 'DateRange' },
-    // Structured
-    JSON: { component: 'ACodeEditor', fieldtype: 'JSON' },
-    Code: { component: 'ACodeEditor', fieldtype: 'Code' },
-    // Relational
-    Link: { component: 'ALink', fieldtype: 'Link' },
-    Doctype: { component: 'AForm', fieldtype: 'Doctype' },
-    // Files
-    Attach: { component: 'AFileAttach', fieldtype: 'Attach' },
-    // Specialized
-    Currency: { component: 'ACurrencyInput', fieldtype: 'Currency' },
-    Quantity: { component: 'AQuantityInput', fieldtype: 'Quantity' },
-    Select: { component: 'ADropdown', fieldtype: 'Select' },
-};
-/**
- * Get the default component for a field type
- * @param fieldtype - The semantic field type
- * @returns The default component name
- * @public
- */
-export function getDefaultComponent(fieldtype) {
-    return TYPE_MAP[fieldtype]?.component ?? 'ATextInput';
-}

package/dist/src/index.js

@@ -1,12 +0,0 @@
-// Field types
-export { StonecropFieldType, TYPE_MAP, getDefaultComponent } from './fieldtype';
-// Field schema
-export { FieldMeta, FieldOptions, FieldValidation } from './field';
-// Doctype schema
-export { DoctypeMeta, WorkflowMeta, ActionDefinition, } from './doctype';
-// Validation helpers
-export { validateField, validateDoctype, parseField, parseDoctype, } from './validation';
-// GraphQL to Doctype conversion
-export { convertGraphQLSchema, GQL_SCALAR_MAP, WELL_KNOWN_SCALARS, INTERNAL_SCALARS, buildScalarMap, defaultIsEntityType, defaultIsEntityField, classifyFieldType, } from './converter';
-// Naming utilities
-export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';

package/dist/src/jsonschema.d.ts

@@ -1,95 +0,0 @@
-import type { DoctypeMeta } from './doctype';
-/**
- * JSON Schema representation for a doctype
- * @public
- */
-export interface DoctypeJSONSchema {
-    /** JSON Schema for the doctype structure */
-    schema: Record<string, unknown>;
-    /** Metadata from the doctype definition */
-    meta: {
-        name: string;
-        slug?: string;
-        tableName?: string;
-        inherits?: string;
-        listDoctype?: string;
-        parentDoctype?: string;
-    };
-    /** Workflow metadata if present */
-    workflow?: {
-        states?: string[];
-        actions?: Record<string, Record<string, unknown>>;
-    };
-}
-/**
- * Convert a DoctypeMeta to JSON Schema
- *
- * @param doctype - The doctype definition to convert
- * @returns JSON Schema representation of the doctype
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toJSONSchema } from '@stonecrop/schema'
- *
- * const taskDoctype = DoctypeMeta.parse({
- *   name: 'Task',
- *   fields: [
- *     { fieldname: 'title', fieldtype: 'Data', required: true },
- *     { fieldname: 'status', fieldtype: 'Select', options: ['Open', 'Closed'] }
- *   ]
- * })
- *
- * const jsonSchema = toJSONSchema(taskDoctype)
- * // => {
- * //   schema: { type: 'object', properties: { title: {...}, status: {...} }, required: ['title'] },
- * //   meta: { name: 'Task' }
- * // }
- * ```
- *
- * @public
- */
-export declare function toJSONSchema(doctype: DoctypeMeta): DoctypeJSONSchema;
-/**
- * Generate a collection of JSON Schemas from multiple doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns Map of doctype name to JSON Schema
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toSchemasCollection } from '@stonecrop/schema'
- *
- * const doctypes = [
- *   DoctypeMeta.parse({ name: 'Task', fields: [...] }),
- *   DoctypeMeta.parse({ name: 'Customer', fields: [...] }),
- * ]
- *
- * const collection = toSchemasCollection(doctypes)
- * // => { Task: {...}, Customer: {...} }
- * ```
- *
- * @public
- */
-export declare function toSchemasCollection(doctypes: DoctypeMeta[]): Record<string, DoctypeJSONSchema>;
-/**
- * Generate OpenAPI schema components from doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns OpenAPI 3.1 compatible components object
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toOpenAPIComponents } from '@stonecrop/schema'
- *
- * const doctypes = [DoctypeMeta.parse({ name: 'Task', fields: [...] })]
- *
- * const components = toOpenAPIComponents(doctypes)
- * // => { schemas: { Task: {...} } }
- * ```
- *
- * @public
- */
-export declare function toOpenAPIComponents(doctypes: DoctypeMeta[]): {
-    schemas: Record<string, Record<string, unknown>>;
-};
-//# sourceMappingURL=jsonschema.d.ts.map

package/dist/src/jsonschema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonschema.d.ts","sourceRoot":"","sources":["../../src/jsonschema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAkC,MAAM,WAAW,CAAA;AAI5E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IACjC,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE/B,2CAA2C;IAC3C,IAAI,EAAE;QACL,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,aAAa,CAAC,EAAE,MAAM,CAAA;KACtB,CAAA;IAED,mCAAmC;IACnC,QAAQ,CAAC,EAAE;QACV,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;KACjD,CAAA;CACD;AAuGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,iBAAiB,CAmDpE;AAsBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAQ9F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,CASjH"}

package/dist/src/naming.js

@@ -1,106 +0,0 @@
-/**
- * Naming Convention Utilities
- * Converts between various naming conventions (snake_case, camelCase, PascalCase, kebab-case)
- * @packageDocumentation
- */
-/**
- * Converts snake_case to camelCase
- * @param snakeCase - Snake case string
- * @returns Camel case string
- * @public
- * @example
- * ```typescript
- * snakeToCamel('user_email') // 'userEmail'
- * snakeToCamel('created_at') // 'createdAt'
- * ```
- */
-export function snakeToCamel(snakeCase) {
-    return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-/**
- * Converts camelCase to snake_case
- * @param camelCase - Camel case string
- * @returns Snake case string
- * @public
- * @example
- * ```typescript
- * camelToSnake('userEmail') // 'user_email'
- * camelToSnake('createdAt') // 'created_at'
- * ```
- */
-export function camelToSnake(camelCase) {
-    return camelCase.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-}
-/**
- * Converts snake_case to Title Case label
- * @param snakeCase - Snake case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * snakeToLabel('user_email') // 'User Email'
- * snakeToLabel('first_name') // 'First Name'
- * ```
- */
-export function snakeToLabel(snakeCase) {
-    return snakeCase
-        .split('_')
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(' ');
-}
-/**
- * Converts camelCase to Title Case label
- * @param camelCase - Camel case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * camelToLabel('userEmail') // 'User Email'
- * camelToLabel('firstName') // 'First Name'
- * ```
- */
-export function camelToLabel(camelCase) {
-    const withSpaces = camelCase.replace(/([A-Z])/g, ' $1').trim();
-    return withSpaces.charAt(0).toUpperCase() + withSpaces.slice(1);
-}
-/**
- * Convert table name to PascalCase doctype name
- * @param tableName - SQL table name (snake_case)
- * @returns PascalCase name
- * @public
- */
-export function toPascalCase(tableName) {
-    return tableName
-        .split(/[-_\s]+/)
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join('');
-}
-/**
- * Convert to kebab-case slug
- * @param name - Name to convert
- * @returns kebab-case slug
- * @public
- */
-export function toSlug(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/[\s_]+/g, '-')
-        .toLowerCase();
-}
-/**
- * Convert PascalCase to snake_case (e.g., for deriving table names from type names)
- * @param pascal - PascalCase string
- * @returns snake_case string
- * @public
- * @example
- * ```typescript
- * pascalToSnake('SalesOrder') // 'sales_order'
- * pascalToSnake('SalesOrderItem') // 'sales_order_item'
- * ```
- */
-export function pascalToSnake(pascal) {
-    return pascal
-        .replace(/([a-z])([A-Z])/g, '$1_$2')
-        .replace(/[\s-]+/g, '_')
-        .toLowerCase();
-}

package/dist/src/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.57.0"
-    }
-  ]
-}

package/dist/src/validation.js

@@ -1,60 +0,0 @@
-import { FieldMeta } from './field';
-import { DoctypeMeta } from './doctype';
-/**
- * Validate a field definition
- * @param data - Data to validate
- * @returns Validation result
- * @public
- */
-export function validateField(data) {
-    const result = FieldMeta.safeParse(data);
-    if (result.success) {
-        return { success: true, errors: [] };
-    }
-    return {
-        success: false,
-        errors: result.error.issues.map(issue => ({
-            path: issue.path,
-            message: issue.message,
-        })),
-    };
-}
-/**
- * Validate a doctype definition
- * @param data - Data to validate
- * @returns Validation result
- * @public
- */
-export function validateDoctype(data) {
-    const result = DoctypeMeta.safeParse(data);
-    if (result.success) {
-        return { success: true, errors: [] };
-    }
-    return {
-        success: false,
-        errors: result.error.issues.map(issue => ({
-            path: issue.path,
-            message: issue.message,
-        })),
-    };
-}
-/**
- * Parse and validate a field, throwing on failure
- * @param data - Data to parse
- * @returns Validated FieldMeta
- * @throws ZodError if validation fails
- * @public
- */
-export function parseField(data) {
-    return FieldMeta.parse(data);
-}
-/**
- * Parse and validate a doctype, throwing on failure
- * @param data - Data to parse
- * @returns Validated DoctypeMeta
- * @throws ZodError if validation fails
- * @public
- */
-export function parseDoctype(data) {
-    return DoctypeMeta.parse(data);
-}