@compilr-dev/factory 0.1.1

package/dist/model/defaults.js

@@ -0,0 +1,68 @@
+/**
+ * Default Model Creators
+ *
+ * Factory functions for creating ApplicationModel and Entity instances
+ * with sensible defaults.
+ */
+import { toPlural } from './naming.js';
+const FACTORY_VERSION = '0.1.0';
+export function createDefaultModel(overrides) {
+    const now = new Date().toISOString();
+    return {
+        identity: {
+            name: 'My Application',
+            description: 'A new application',
+            version: '1.0.0',
+            ...overrides?.identity,
+        },
+        entities: overrides?.entities ?? [],
+        layout: {
+            shell: 'sidebar-header',
+            ...overrides?.layout,
+        },
+        features: {
+            dashboard: true,
+            auth: false,
+            userProfiles: false,
+            settings: false,
+            darkMode: false,
+            ...overrides?.features,
+        },
+        theme: {
+            primaryColor: '#3B82F6',
+            ...overrides?.theme,
+        },
+        techStack: {
+            toolkit: 'react-node',
+            ...overrides?.techStack,
+        },
+        meta: {
+            revision: 1,
+            createdAt: now,
+            updatedAt: now,
+            factoryVersion: FACTORY_VERSION,
+            ...overrides?.meta,
+        },
+    };
+}
+export function createDefaultEntity(name, overrides) {
+    const entityName = overrides?.name ?? name;
+    return {
+        name: entityName,
+        pluralName: overrides?.pluralName ?? toPlural(entityName),
+        icon: overrides?.icon ?? '📄',
+        fields: overrides?.fields ?? [],
+        views: overrides?.views ?? ['list', 'detail'],
+        relationships: overrides?.relationships ?? [],
+        description: overrides?.description,
+    };
+}
+export function createDefaultField(name, label, overrides) {
+    return {
+        name,
+        label,
+        type: 'string',
+        required: false,
+        ...overrides,
+    };
+}

package/dist/model/naming.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Naming Utilities
+ *
+ * Converts between naming conventions used in the Application Model.
+ */
+export declare function toPascalCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function toKebabCase(str: string): string;
+export declare function toPlural(str: string): string;
+export declare function isPascalCase(str: string): boolean;
+export declare function isCamelCase(str: string): boolean;
+export declare function isValidHexColor(str: string): boolean;

package/dist/model/naming.js

@@ -0,0 +1,80 @@
+/**
+ * Naming Utilities
+ *
+ * Converts between naming conventions used in the Application Model.
+ */
+const IRREGULAR_PLURALS = {
+    person: 'people',
+    child: 'children',
+    mouse: 'mice',
+    goose: 'geese',
+    man: 'men',
+    woman: 'women',
+    tooth: 'teeth',
+    foot: 'feet',
+    datum: 'data',
+    analysis: 'analyses',
+    crisis: 'crises',
+    criterion: 'criteria',
+    phenomenon: 'phenomena',
+    index: 'indices',
+    matrix: 'matrices',
+    vertex: 'vertices',
+    appendix: 'appendices',
+    ox: 'oxen',
+    quiz: 'quizzes',
+    status: 'statuses',
+    bus: 'buses',
+};
+export function toPascalCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+export function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+export function toKebabCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+export function toPlural(str) {
+    const lower = str.toLowerCase();
+    if (IRREGULAR_PLURALS[lower]) {
+        const plural = IRREGULAR_PLURALS[lower];
+        if (str[0] === str[0].toUpperCase()) {
+            return plural.charAt(0).toUpperCase() + plural.slice(1);
+        }
+        return plural;
+    }
+    if (str.endsWith('s') ||
+        str.endsWith('sh') ||
+        str.endsWith('ch') ||
+        str.endsWith('x') ||
+        str.endsWith('z')) {
+        return str + 'es';
+    }
+    if (str.endsWith('y') && !/[aeiou]y$/i.test(str)) {
+        return str.slice(0, -1) + 'ies';
+    }
+    if (str.endsWith('f')) {
+        return str.slice(0, -1) + 'ves';
+    }
+    if (str.endsWith('fe')) {
+        return str.slice(0, -2) + 'ves';
+    }
+    return str + 's';
+}
+export function isPascalCase(str) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+export function isCamelCase(str) {
+    return /^[a-z][a-zA-Z0-9]*$/.test(str);
+}
+export function isValidHexColor(str) {
+    return /^#[0-9A-Fa-f]{6}$/.test(str);
+}

package/dist/model/operations-entity.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Entity Operations
+ *
+ * addEntity, updateEntity, removeEntity, renameEntity, reorderEntities
+ */
+import type { ApplicationModel, Entity } from './types.js';
+export interface AddEntityOp {
+    readonly op: 'addEntity';
+    readonly entity: Entity;
+}
+export interface UpdateEntityOp {
+    readonly op: 'updateEntity';
+    readonly entity: string;
+    readonly updates: Partial<Omit<Entity, 'name' | 'relationships'>>;
+}
+export interface RemoveEntityOp {
+    readonly op: 'removeEntity';
+    readonly entity: string;
+    readonly force?: boolean;
+}
+export interface RenameEntityOp {
+    readonly op: 'renameEntity';
+    readonly entity: string;
+    readonly newName: string;
+}
+export interface ReorderEntitiesOp {
+    readonly op: 'reorderEntities';
+    readonly order: readonly string[];
+}
+export type EntityOperation = AddEntityOp | UpdateEntityOp | RemoveEntityOp | RenameEntityOp | ReorderEntitiesOp;
+export declare function addEntity(model: ApplicationModel, op: AddEntityOp): ApplicationModel;
+export declare function updateEntity(model: ApplicationModel, op: UpdateEntityOp): ApplicationModel;
+export declare function removeEntity(model: ApplicationModel, op: RemoveEntityOp): ApplicationModel;
+export declare function renameEntity(model: ApplicationModel, op: RenameEntityOp): ApplicationModel;
+export declare function reorderEntities(model: ApplicationModel, op: ReorderEntitiesOp): ApplicationModel;

package/dist/model/operations-entity.js

@@ -0,0 +1,110 @@
+/**
+ * Entity Operations
+ *
+ * addEntity, updateEntity, removeEntity, renameEntity, reorderEntities
+ */
+import { isPascalCase } from './naming.js';
+function findEntity(model, name) {
+    const entity = model.entities.find((e) => e.name === name);
+    if (!entity) {
+        throw new Error(`Entity "${name}" not found`);
+    }
+    return entity;
+}
+export function addEntity(model, op) {
+    const { entity } = op;
+    if (!entity.name || !isPascalCase(entity.name)) {
+        throw new Error(`Entity name "${entity.name}" must be non-empty PascalCase`);
+    }
+    if (model.entities.some((e) => e.name === entity.name)) {
+        throw new Error(`Entity "${entity.name}" already exists`);
+    }
+    return {
+        ...model,
+        entities: [...model.entities, entity],
+    };
+}
+export function updateEntity(model, op) {
+    findEntity(model, op.entity);
+    return {
+        ...model,
+        entities: model.entities.map((e) => {
+            if (e.name !== op.entity)
+                return e;
+            return {
+                ...e,
+                ...op.updates,
+                name: e.name,
+                relationships: e.relationships,
+            };
+        }),
+    };
+}
+export function removeEntity(model, op) {
+    findEntity(model, op.entity);
+    const referencingEntities = model.entities.filter((e) => e.name !== op.entity && e.relationships.some((r) => r.target === op.entity));
+    if (referencingEntities.length > 0 && !op.force) {
+        const names = referencingEntities.map((e) => e.name).join(', ');
+        throw new Error(`Cannot remove "${op.entity}": referenced by ${names}. Use force: true to cascade.`);
+    }
+    let entities = model.entities.filter((e) => e.name !== op.entity);
+    if (op.force) {
+        entities = entities.map((e) => ({
+            ...e,
+            relationships: e.relationships.filter((r) => r.target !== op.entity),
+        }));
+    }
+    return { ...model, entities };
+}
+export function renameEntity(model, op) {
+    findEntity(model, op.entity);
+    if (!op.newName || !isPascalCase(op.newName)) {
+        throw new Error(`New entity name "${op.newName}" must be non-empty PascalCase`);
+    }
+    if (op.entity !== op.newName && model.entities.some((e) => e.name === op.newName)) {
+        throw new Error(`Entity "${op.newName}" already exists`);
+    }
+    return {
+        ...model,
+        entities: model.entities.map((e) => {
+            let entity = e;
+            // Rename the entity itself
+            if (entity.name === op.entity) {
+                entity = { ...entity, name: op.newName };
+            }
+            // Update relationship targets
+            const hasTargetRef = entity.relationships.some((r) => r.target === op.entity);
+            if (hasTargetRef) {
+                entity = {
+                    ...entity,
+                    relationships: entity.relationships.map((r) => {
+                        if (r.target !== op.entity)
+                            return r;
+                        return { ...r, target: op.newName };
+                    }),
+                };
+            }
+            return entity;
+        }),
+    };
+}
+export function reorderEntities(model, op) {
+    const currentNames = model.entities.map((e) => e.name);
+    const orderNames = [...op.order];
+    if (orderNames.length !== currentNames.length) {
+        throw new Error(`Order must contain exactly ${String(currentNames.length)} entities, got ${String(orderNames.length)}`);
+    }
+    for (const name of orderNames) {
+        if (!currentNames.includes(name)) {
+            throw new Error(`Entity "${name}" in order does not exist`);
+        }
+    }
+    const entityMap = new Map(model.entities.map((e) => [e.name, e]));
+    const reordered = orderNames.map((name) => {
+        const entity = entityMap.get(name);
+        if (!entity)
+            throw new Error(`Entity "${name}" in order does not exist`);
+        return entity;
+    });
+    return { ...model, entities: reordered };
+}

package/dist/model/operations-field.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Field Operations
+ *
+ * addField, updateField, removeField, renameField
+ */
+import type { ApplicationModel, Field } from './types.js';
+export interface AddFieldOp {
+    readonly op: 'addField';
+    readonly entity: string;
+    readonly field: Field;
+}
+export interface UpdateFieldOp {
+    readonly op: 'updateField';
+    readonly entity: string;
+    readonly field: string;
+    readonly updates: Partial<Omit<Field, 'name'>>;
+}
+export interface RemoveFieldOp {
+    readonly op: 'removeField';
+    readonly entity: string;
+    readonly field: string;
+}
+export interface RenameFieldOp {
+    readonly op: 'renameField';
+    readonly entity: string;
+    readonly field: string;
+    readonly newName: string;
+}
+export type FieldOperation = AddFieldOp | UpdateFieldOp | RemoveFieldOp | RenameFieldOp;
+export declare function addField(model: ApplicationModel, op: AddFieldOp): ApplicationModel;
+export declare function updateField(model: ApplicationModel, op: UpdateFieldOp): ApplicationModel;
+export declare function removeField(model: ApplicationModel, op: RemoveFieldOp): ApplicationModel;
+export declare function renameField(model: ApplicationModel, op: RenameFieldOp): ApplicationModel;

package/dist/model/operations-field.js

@@ -0,0 +1,104 @@
+/**
+ * Field Operations
+ *
+ * addField, updateField, removeField, renameField
+ */
+import { isCamelCase } from './naming.js';
+function findEntity(model, name) {
+    const index = model.entities.findIndex((e) => e.name === name);
+    if (index === -1) {
+        throw new Error(`Entity "${name}" not found`);
+    }
+    return index;
+}
+function findField(model, entityName, fieldName) {
+    const entityIdx = findEntity(model, entityName);
+    const entity = model.entities[entityIdx];
+    const fieldIdx = entity.fields.findIndex((f) => f.name === fieldName);
+    if (fieldIdx === -1) {
+        throw new Error(`Field "${fieldName}" not found in entity "${entityName}"`);
+    }
+    return fieldIdx;
+}
+function updateEntityAt(model, entityIdx, updater) {
+    return {
+        ...model,
+        entities: model.entities.map((e, i) => {
+            if (i !== entityIdx)
+                return e;
+            return { ...e, fields: updater(e.fields) };
+        }),
+    };
+}
+export function addField(model, op) {
+    const entityIdx = findEntity(model, op.entity);
+    const entity = model.entities[entityIdx];
+    if (!op.field.name || !isCamelCase(op.field.name)) {
+        throw new Error(`Field name "${op.field.name}" must be non-empty camelCase`);
+    }
+    if (entity.fields.some((f) => f.name === op.field.name)) {
+        throw new Error(`Field "${op.field.name}" already exists in entity "${op.entity}"`);
+    }
+    return updateEntityAt(model, entityIdx, (fields) => [...fields, op.field]);
+}
+export function updateField(model, op) {
+    const entityIdx = findEntity(model, op.entity);
+    findField(model, op.entity, op.field);
+    return updateEntityAt(model, entityIdx, (fields) => fields.map((f) => {
+        if (f.name !== op.field)
+            return f;
+        return { ...f, ...op.updates, name: f.name };
+    }));
+}
+export function removeField(model, op) {
+    const entityIdx = findEntity(model, op.entity);
+    findField(model, op.entity, op.field);
+    // Check if field is a FK field
+    const entity = model.entities[entityIdx];
+    const isFk = entity.relationships.some((r) => {
+        const fkField = r.fieldName ?? `${r.target.charAt(0).toLowerCase()}${r.target.slice(1)}Id`;
+        return r.type === 'belongsTo' && fkField === op.field;
+    });
+    if (isFk) {
+        throw new Error(`Cannot remove field "${op.field}": it is a foreign key. Remove the relationship first.`);
+    }
+    return updateEntityAt(model, entityIdx, (fields) => fields.filter((f) => f.name !== op.field));
+}
+export function renameField(model, op) {
+    const entityIdx = findEntity(model, op.entity);
+    findField(model, op.entity, op.field);
+    if (!op.newName || !isCamelCase(op.newName)) {
+        throw new Error(`New field name "${op.newName}" must be non-empty camelCase`);
+    }
+    const entity = model.entities[entityIdx];
+    if (op.field !== op.newName && entity.fields.some((f) => f.name === op.newName)) {
+        throw new Error(`Field "${op.newName}" already exists in entity "${op.entity}"`);
+    }
+    // Rename the field
+    let result = updateEntityAt(model, entityIdx, (fields) => fields.map((f) => {
+        if (f.name !== op.field)
+            return f;
+        return { ...f, name: op.newName };
+    }));
+    // Update relationship fieldName if this was a FK field
+    result = {
+        ...result,
+        entities: result.entities.map((e) => {
+            if (e.name !== op.entity)
+                return e;
+            return {
+                ...e,
+                relationships: e.relationships.map((r) => {
+                    if (r.type !== 'belongsTo')
+                        return r;
+                    const defaultFk = `${r.target.charAt(0).toLowerCase()}${r.target.slice(1)}Id`;
+                    const currentFk = r.fieldName ?? defaultFk;
+                    if (currentFk !== op.field)
+                        return r;
+                    return { ...r, fieldName: op.newName };
+                }),
+            };
+        }),
+    };
+    return result;
+}

package/dist/model/operations-relationship.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Relationship Operations
+ *
+ * addRelationship (with auto-inverse), removeRelationship (with auto-inverse cleanup)
+ */
+import type { ApplicationModel, Relationship } from './types.js';
+export interface AddRelationshipOp {
+    readonly op: 'addRelationship';
+    readonly entity: string;
+    readonly relationship: Relationship;
+}
+export interface RemoveRelationshipOp {
+    readonly op: 'removeRelationship';
+    readonly entity: string;
+    readonly target: string;
+}
+export type RelationshipOperation = AddRelationshipOp | RemoveRelationshipOp;
+export declare function addRelationship(model: ApplicationModel, op: AddRelationshipOp): ApplicationModel;
+export declare function removeRelationship(model: ApplicationModel, op: RemoveRelationshipOp): ApplicationModel;

package/dist/model/operations-relationship.js

@@ -0,0 +1,90 @@
+/**
+ * Relationship Operations
+ *
+ * addRelationship (with auto-inverse), removeRelationship (with auto-inverse cleanup)
+ */
+function getEntity(model, name) {
+    const entity = model.entities.find((e) => e.name === name);
+    if (!entity) {
+        throw new Error(`Entity "${name}" not found`);
+    }
+    return entity;
+}
+function addInverse(result, targetName, inverseType, inverseTarget) {
+    const targetEntity = getEntity(result, targetName);
+    const hasInverse = targetEntity.relationships.some((r) => r.type === inverseType && r.target === inverseTarget);
+    if (hasInverse)
+        return result;
+    return {
+        ...result,
+        entities: result.entities.map((e) => {
+            if (e.name !== targetName)
+                return e;
+            return {
+                ...e,
+                relationships: [...e.relationships, { type: inverseType, target: inverseTarget }],
+            };
+        }),
+    };
+}
+export function addRelationship(model, op) {
+    getEntity(model, op.entity);
+    getEntity(model, op.relationship.target);
+    if (op.relationship.target === op.entity) {
+        throw new Error('Self-referential relationships are not supported');
+    }
+    // Check for duplicate
+    const entity = getEntity(model, op.entity);
+    const exists = entity.relationships.some((r) => r.type === op.relationship.type && r.target === op.relationship.target);
+    if (exists) {
+        throw new Error(`Relationship ${op.relationship.type} → ${op.relationship.target} already exists on "${op.entity}"`);
+    }
+    let result = {
+        ...model,
+        entities: model.entities.map((e) => {
+            if (e.name !== op.entity)
+                return e;
+            return {
+                ...e,
+                relationships: [...e.relationships, op.relationship],
+            };
+        }),
+    };
+    // Auto-add inverse
+    const inverseType = op.relationship.type === 'belongsTo' ? 'hasMany' : 'belongsTo';
+    result = addInverse(result, op.relationship.target, inverseType, op.entity);
+    return result;
+}
+export function removeRelationship(model, op) {
+    const entity = getEntity(model, op.entity);
+    const rel = entity.relationships.find((r) => r.target === op.target);
+    if (!rel) {
+        throw new Error(`No relationship to "${op.target}" found on entity "${op.entity}"`);
+    }
+    // Remove the relationship
+    let result = {
+        ...model,
+        entities: model.entities.map((e) => {
+            if (e.name !== op.entity)
+                return e;
+            return {
+                ...e,
+                relationships: e.relationships.filter((r) => r.target !== op.target),
+            };
+        }),
+    };
+    // Auto-remove inverse
+    const inverseType = rel.type === 'belongsTo' ? 'hasMany' : 'belongsTo';
+    result = {
+        ...result,
+        entities: result.entities.map((e) => {
+            if (e.name !== op.target)
+                return e;
+            return {
+                ...e,
+                relationships: e.relationships.filter((r) => !(r.type === inverseType && r.target === op.entity)),
+            };
+        }),
+    };
+    return result;
+}

package/dist/model/operations-section.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Section Operations
+ *
+ * updateIdentity, updateLayout, updateFeatures, updateTheme, updateTechStack
+ */
+import type { ApplicationModel, Features, Identity, Layout, TechStack, Theme } from './types.js';
+export interface UpdateIdentityOp {
+    readonly op: 'updateIdentity';
+    readonly updates: Partial<Identity>;
+}
+export interface UpdateLayoutOp {
+    readonly op: 'updateLayout';
+    readonly updates: Partial<Layout>;
+}
+export interface UpdateFeaturesOp {
+    readonly op: 'updateFeatures';
+    readonly updates: Partial<Features>;
+}
+export interface UpdateThemeOp {
+    readonly op: 'updateTheme';
+    readonly updates: Partial<Theme>;
+}
+export interface UpdateTechStackOp {
+    readonly op: 'updateTechStack';
+    readonly updates: Partial<TechStack>;
+}
+export type SectionOperation = UpdateIdentityOp | UpdateLayoutOp | UpdateFeaturesOp | UpdateThemeOp | UpdateTechStackOp;
+export declare function updateIdentity(model: ApplicationModel, op: UpdateIdentityOp): ApplicationModel;
+export declare function updateLayout(model: ApplicationModel, op: UpdateLayoutOp): ApplicationModel;
+export declare function updateFeatures(model: ApplicationModel, op: UpdateFeaturesOp): ApplicationModel;
+export declare function updateTheme(model: ApplicationModel, op: UpdateThemeOp): ApplicationModel;
+export declare function updateTechStack(model: ApplicationModel, op: UpdateTechStackOp): ApplicationModel;

package/dist/model/operations-section.js

@@ -0,0 +1,35 @@
+/**
+ * Section Operations
+ *
+ * updateIdentity, updateLayout, updateFeatures, updateTheme, updateTechStack
+ */
+export function updateIdentity(model, op) {
+    return {
+        ...model,
+        identity: { ...model.identity, ...op.updates },
+    };
+}
+export function updateLayout(model, op) {
+    return {
+        ...model,
+        layout: { ...model.layout, ...op.updates },
+    };
+}
+export function updateFeatures(model, op) {
+    return {
+        ...model,
+        features: { ...model.features, ...op.updates },
+    };
+}
+export function updateTheme(model, op) {
+    return {
+        ...model,
+        theme: { ...model.theme, ...op.updates },
+    };
+}
+export function updateTechStack(model, op) {
+    return {
+        ...model,
+        techStack: { ...model.techStack, ...op.updates },
+    };
+}

package/dist/model/operations.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Operation Dispatcher
+ *
+ * Routes op → handler, manages revision + updatedAt.
+ */
+import type { ApplicationModel } from './types.js';
+import { type EntityOperation } from './operations-entity.js';
+import { type FieldOperation } from './operations-field.js';
+import { type RelationshipOperation } from './operations-relationship.js';
+import { type SectionOperation } from './operations-section.js';
+export type ModelOperation = EntityOperation | FieldOperation | RelationshipOperation | SectionOperation;
+export declare function applyOperation(model: ApplicationModel, operation: ModelOperation): ApplicationModel;