// Stripe doesn't own payment rails
// They implement standard protocols:
interface PaymentProtocol {
  createPaymentIntent(amount: number, currency: string): Promise<PaymentIntent>;
  confirmPayment(intentId: string): Promise<PaymentResult>;
  refund(chargeId: string, amount?: number): Promise<Refund>;
}

// Multiple providers can implement this:
class StripeProvider implements PaymentProtocol { ... }
class AdyenProvider implements PaymentProtocol { ... }
class SquareProvider implements PaymentProtocol { ... }

# Kubernetes manifests are portable
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: app
        image: myapp:v1.0

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Create",
  "actor": "https://mastodon.social/@alice",
  "object": {
    "type": "Note",
    "content": "Hello, decentralized world!"
  }
}

<!-- Salesforce metadata format -->
<CustomObject xmlns="http://soap.sforce.com/2006/04/metadata">
    <fullName>Project__c</fullName>
    <label>Project</label>
    <fields>
        <fullName>Title__c</fullName>
        <type>Text</type>
        <length>255</length>
        <required>true</required>
    </fields>
</CustomObject>

import { z } from 'zod';
import { ObjectProtocol, Field } from '@objectstack/spec';

export const ProjectSchema = ObjectProtocol.define({
  name: 'project',
  label: 'Project',
  fields: {
    title: Field.text({
      required: true,
      maxLength: 255,
      label: 'Title'
    })
  }
});

// Automatic TypeScript type
type Project = z.infer<typeof ProjectSchema>;

// Automatic JSON Schema
const jsonSchema = zodToJsonSchema(ProjectSchema);

// Automatic runtime validation
const validated = ProjectSchema.parse(data);

// Use any Zod-compatible library
import { zodToJsonSchema } from 'zod-to-json-schema';
import { generateMock } from '@anatine/zod-mock';
import { zodToOpenAPI } from '@asteasolutions/zod-to-openapi';

// Generate API documentation
const openApiSpec = zodToOpenAPI(ProjectSchema);

// Generate mock data for testing
const mockProject = generateMock(ProjectSchema);

// Validate forms automatically
function FormField({ schema }: { schema: z.ZodType }) {
  const [error, setError] = useState<string | null>(null);
  
  const handleChange = (value: any) => {
    try {
      schema.parse(value);
      setError(null);
    } catch (e) {
      setError(e.message);
    }
  };
  
  return <Input onChange={handleChange} error={error} />;
}

// Salesforce SOQL (proprietary query language)
SELECT Id, Name, (SELECT Title FROM Projects__r) 
FROM Account 
WHERE Industry = 'Technology'

// Define the protocol
interface QueryProtocol {
  find(object: string, filters: Filter[]): Promise<Record[]>;
  findOne(object: string, id: string): Promise<Record>;
  create(object: string, data: Record): Promise<Record>;
  update(object: string, id: string, data: Partial<Record>): Promise<Record>;
  delete(object: string, id: string): Promise<void>;
}

// Implement for PostgreSQL
class PostgresAdapter implements QueryProtocol {
  async find(object: string, filters: Filter[]) {
    const query = this.buildQuery(object, filters);
    return this.db.query(query);
  }
  
  private buildQuery(object: string, filters: Filter[]) {
    // Translate protocol filters to SQL
    const where = filters.map(f => `${f.field} ${f.operator} $${f.value}`);
    return {
      text: `SELECT * FROM ${object} WHERE ${where.join(' AND ')}`,
      values: filters.map(f => f.value)
    };
  }
}

// Implement for MongoDB
class MongoAdapter implements QueryProtocol {
  async find(object: string, filters: Filter[]) {
    const query = this.buildQuery(filters);
    return this.db.collection(object).find(query).toArray();
  }
  
  private buildQuery(filters: Filter[]) {
    // Translate protocol filters to MongoDB query
    const query: any = {};
    filters.forEach(f => {
      query[f.field] = { [`$${f.operator}`]: f.value };
    });
    return query;
  }
}

// Complex analytics query in PostgreSQL
const adapter = new PostgresAdapter(db);

// This would hit Salesforce's governor limits
const results = await adapter.find('opportunity', [
  { field: 'amount', operator: '>', value: 100000 },
  { field: 'stage', operator: 'in', value: ['Negotiation', 'Closed Won'] }
]);

// But in Postgres, we can do this efficiently:
await db.query(`
  WITH monthly_revenue AS (
    SELECT 
      DATE_TRUNC('month', close_date) AS month,
      SUM(amount) AS revenue
    FROM opportunities
    WHERE stage = 'Closed Won'
    GROUP BY month
  )
  SELECT 
    month,
    revenue,
    AVG(revenue) OVER (ORDER BY month ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS three_month_avg
  FROM monthly_revenue
  ORDER BY month DESC
`);

// Everything is open source and versioned
// github.com/objectstack-ai/spec

export const FieldTypes = {
  text: z.object({
    type: z.literal('text'),
    maxLength: z.number().optional(),
    minLength: z.number().optional(),
    pattern: z.string().optional(),
    required: z.boolean().default(false),
    multiple: z.boolean().default(false)
  }),
  
  number: z.object({
    type: z.literal('number'),
    min: z.number().optional(),
    max: z.number().optional(),
    precision: z.number().optional(),
    required: z.boolean().default(false)
  }),
  
  // ... all field types defined in Zod
};

// Version is explicit
export const PROTOCOL_VERSION = '1.0.0';

// Breaking changes require major version bump
// New fields can be added (backward compatible)
// Deprecations follow semantic versioning

// Reference implementation (TypeScript)
class TypeScriptRuntime implements ObjectStackRuntime { ... }

// Community implementations
class RustRuntime implements ObjectStackRuntime { ... }
class GoRuntime implements ObjectStackRuntime { ... }
class PythonRuntime implements ObjectStackRuntime { ... }

// Anyone can propose new field types
export const GeoLocationField = Field.custom({
  type: 'geolocation',
  schema: z.object({
    latitude: z.number().min(-90).max(90),
    longitude: z.number().min(-180).max(180),
    accuracy: z.number().optional()
  }),
  ui: {
    widget: 'map-picker',
    defaultZoom: 10
  }
});

// If widely adopted, can be added to core spec

# ObjectStack RFC Process

1. Anyone can propose an RFC (Request for Comments)
2. Community discussion on GitHub
3. Implementation prototypes
4. Consensus building
5. Merge into specification
6. Versioned release

Example: RFC-0042: "Add Support for Computed Fields"
Status: Draft → Under Review → Accepted → Implemented

export interface ObjectMetadata {
  // Protocol version this definition uses
  protocolVersion: string;  // e.g., "1.2.0"
  
  // Schema definition
  name: string;
  fields: Record<string, FieldDefinition>;
  
  // Optional: New features (backward compatible)
  computed?: ComputedFieldDefinition[];  // Added in v1.1.0
  workflows?: WorkflowDefinition[];      // Added in v1.2.0
}

// Runtime capability check
class Runtime {
  supports(feature: string): boolean {
    const [major, minor] = this.version.split('.');
    const capabilities = {
      '1.0': ['basic_fields', 'validation'],
      '1.1': ['basic_fields', 'validation', 'computed_fields'],
      '1.2': ['basic_fields', 'validation', 'computed_fields', 'workflows']
    };
    return capabilities[`${major}.${minor}`]?.includes(feature) || false;
  }
  
  async load(metadata: ObjectMetadata) {
    if (this.isCompatible(metadata.protocolVersion)) {
      return this.interpret(metadata);
    } else {
      throw new Error(`Protocol version ${metadata.protocolVersion} not supported`);
    }
  }
}

// Core protocol
export interface FieldDefinition {
  type: string;
  required?: boolean;
  // ... standard properties
  
  // Extension point
  extensions?: Record<string, unknown>;
}

// Custom extension
const CustomField = Field.text({
  required: true,
  extensions: {
    'com.acme.encryption': {
      algorithm: 'AES-256',
      keyRotation: '90d'
    },
    'com.acme.pii': {
      category: 'sensitive',
      retentionDays: 365
    }
  }
});

// Runtime can ignore unknown extensions
class Runtime {
  interpret(field: FieldDefinition) {
    // Handle core properties
    this.setupField(field);
    
    // Optionally handle known extensions
    if (field.extensions?.['com.acme.encryption']) {
      this.setupEncryption(field);
    }
    
    // Ignore unknown extensions (forward compatibility)
  }
}

// Core protocol defines the interface
export interface StorageAdapter {
  // Lifecycle
  initialize(metadata: ObjectMetadata[]): Promise<void>;
  migrate(from: ObjectMetadata, to: ObjectMetadata): Promise<void>;
  
  // CRUD operations
  create(object: string, data: Record): Promise<Record>;
  read(object: string, id: string): Promise<Record>;
  update(object: string, id: string, data: Partial<Record>): Promise<Record>;
  delete(object: string, id: string): Promise<void>;
  
  // Queries
  find(object: string, query: Query): Promise<Record[]>;
  count(object: string, query: Query): Promise<number>;
  
  // Transactions
  transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
}

// Implementations can optimize per database
class PostgresAdapter implements StorageAdapter {
  async find(object: string, query: Query) {
    // Leverage PostgreSQL-specific features
    const sql = this.compileToSQL(query);
    
    // Use EXPLAIN to check query plan
    const plan = await this.db.query(`EXPLAIN ${sql}`);
    if (!this.isIndexed(plan)) {
      console.warn(`Query on ${object} might be slow - consider adding index`);
    }
    
    return this.db.query(sql);
  }
}

class MongoAdapter implements StorageAdapter {
  async find(object: string, query: Query) {
    // Leverage MongoDB aggregation pipeline
    const pipeline = this.compileToAggregation(query);
    
    // Use explain() to check query plan
    const plan = await this.db.collection(object).explain();
    if (!plan.executionStats.totalDocsExamined < plan.executionStats.nReturned * 10) {
      console.warn(`Query on ${object} scanning too many documents`);
    }
    
    return this.db.collection(object).aggregate(pipeline).toArray();
  }
}

Revenue = Subscriptions + Transaction Fees + Partner App Store Cuts

Margins = High (70%+) due to:
- Vendor lock-in
- Limited competition
- Switching costs

Total Cost = Subscription + Implementation + Custom Development + 
             Integration + Training + Vendor Apps

Hidden Costs:
- Technical debt (can't easily migrate)
- Feature delays (wait for vendor)
- Lost opportunities (constraints limit innovation)

Value = Σ(All Implementations) - Vendor Lock-in Costs

Network Effects = Implementations × Integrations × Extensions

Competition = Open (better implementations win)

Total Cost = Implementation Choice + Development + Integration

Benefits:
- Competitive pricing (multiple vendors)
- Faster innovation (permissionless extensions)
- Risk reduction (can switch implementations)
- True multi-cloud/hybrid

// objects/project.ts
export const Project = ObjectProtocol.define({
  name: 'project',
  label: 'Project',
  fields: {
    name: Field.text({ required: true, maxLength: 100 }),
    description: Field.textarea({ maxLength: 5000 }),
    owner: Field.lookup({ reference: 'user', required: true }),
    status: Field.select({
      options: ['planning', 'active', 'on_hold', 'completed', 'cancelled'],
      default: 'planning'
    }),
    start_date: Field.date(),
    end_date: Field.date(),
    budget: Field.currency({ precision: 2 }),
    team_members: Field.lookup({ reference: 'user', multiple: true })
  },
  enable: {
    trackHistory: true,
    apiEnabled: true,
    searchEnabled: true
  }
});

// objects/task.ts
export const Task = ObjectProtocol.define({
  name: 'task',
  label: 'Task',
  fields: {
    title: Field.text({ required: true }),
    description: Field.textarea(),
    project: Field.lookup({ reference: 'project', required: true }),
    assignee: Field.lookup({ reference: 'user' }),
    status: Field.select({
      options: ['todo', 'in_progress', 'review', 'done'],
      default: 'todo'
    }),
    priority: Field.select({
      options: ['low', 'medium', 'high', 'critical'],
      default: 'medium'
    }),
    due_date: Field.date(),
    estimated_hours: Field.number({ min: 0, precision: 1 }),
    actual_hours: Field.number({ min: 0, precision: 1 })
  },
  enable: {
    trackHistory: true,
    apiEnabled: true
  }
});

// views/project-list.ts
export const ProjectListView = {
  type: 'list',
  object: 'project',
  columns: [
    { field: 'name', width: 300 },
    { field: 'owner', width: 150 },
    { field: 'status', width: 120 },
    { field: 'start_date', width: 120 },
    { field: 'budget', width: 120 }
  ],
  filters: [
    { field: 'status', operator: '!=', value: 'cancelled' }
  ],
  sorts: [
    { field: 'start_date', direction: 'desc' }
  ],
  actions: [
    { type: 'create', label: 'New Project' },
    { type: 'export', label: 'Export to CSV' }
  ]
};

// views/project-kanban.ts
export const ProjectKanbanView = {
  type: 'kanban',
  object: 'task',
  groupBy: 'status',
  cardFields: ['title', 'assignee', 'due_date', 'priority'],
  filters: [
    { field: 'project', operator: '=', value: '${current_project_id}' }
  ]
};

// workflows/project-approval.ts
export const ProjectApprovalWorkflow = {
  name: 'project_approval',
  trigger: {
    object: 'project',
    events: ['create', 'update'],
    conditions: [
      { field: 'budget', operator: '>', value: 50000 }
    ]
  },
  actions: [
    {
      type: 'update_field',
      field: 'status',
      value: 'pending_approval'
    },
    {
      type: 'send_email',
      to: { lookup: 'owner.manager.email' },
      template: 'project_approval_request',
      data: {
        project_name: '${record.name}',
        budget: '${record.budget}',
        approval_link: '${record.approval_url}'
      }
    },
    {
      type: 'create_task',
      object: 'approval',
      data: {
        type: 'project_approval',
        project: '${record.id}',
        approver: '${record.owner.manager.id}',
        status: 'pending'
      }
    }
  ]
};

// Runtime configuration
import { Runtime } from '@objectstack/runtime';
import { PostgresAdapter } from '@objectstack/adapter-postgres';
import { ReactRenderer } from '@objectstack/renderer-react';

const runtime = new Runtime({
  storage: new PostgresAdapter({
    host: process.env.DB_HOST,
    database: 'projectmgmt',
    ssl: true
  }),
  renderer: new ReactRenderer({
    theme: 'default',
    customComponents: {
      'gantt-chart': GanttChartComponent
    }
  }),
  objects: [Project, Task],
  views: [ProjectListView, ProjectKanbanView],
  workflows: [ProjectApprovalWorkflow]
});

// Deploy
await runtime.initialize();
await runtime.serve(3000);

Build on Platform → Get Locked In → Pay Rent Forever

Implement Protocol → Choose Best Implementation → Switch When Better Option Exists