@spacemade/ui 0.0.1

package/scripts/defs/nft-definition.mjs

@@ -0,0 +1,191 @@
+import {
+  createCrudScaffoldDefinition,
+  field,
+} from '../crud-scaffold/src/generator.mjs'
+
+const status = {
+  mint: ['draft', 'minting', 'minted', 'failed'],
+  job: ['queued', 'running', 'completed', 'failed'],
+  listing: ['draft', 'active', 'sold', 'cancelled'],
+}
+
+const scopedFields = () => [
+  field.uuid('org_id', { nullable: true, references: 'org', skipSchema: true, hideInTable: true }),
+  field.uuid('project_id', { nullable: true, references: 'project', skipSchema: true, hideInTable: true }),
+]
+
+const resources = [
+  {
+    name: 'NftCollection',
+    slug: 'nft-collection',
+    route: 'nft-collections',
+    responseKey: 'nftCollection',
+    title: 'Collections',
+    icon: 'bi bi-collection',
+    description: 'Create blockchain-backed collections of minted NFT items.',
+    searchFields: ['name', 'slug', 'chain'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('creator_user_id', { nullable: true, references: 'user' }),
+      field.string('name', { required: true, minLength: 2 }),
+      field.string('slug', { required: true, regex: 'SLUG_REGEX' }),
+      field.text('description', { nullable: true }),
+      field.string('chain', { required: true }),
+    ],
+  },
+  {
+    name: 'NftItem',
+    slug: 'nft-item',
+    route: 'nft-items',
+    responseKey: 'nftItem',
+    title: 'NFT Items',
+    icon: 'bi bi-gem',
+    description: 'Manage token media, metadata, and minting state.',
+    searchFields: ['token_id', 'name', 'mint_status'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('nft_collection_id', { required: true, references: 'nft_collection', onDelete: 'CASCADE' }),
+      field.string('token_id', { nullable: true }),
+      field.string('name', { required: true, minLength: 2 }),
+      field.string('image_url', { required: true }),
+      field.string('metadata_url', { nullable: true }),
+      field.enum('mint_status', status.mint, { defaultValue: 'draft' }),
+    ],
+  },
+  {
+    name: 'NftWalletAccount',
+    slug: 'nft-wallet-account',
+    route: 'nft-wallet-accounts',
+    responseKey: 'nftWalletAccount',
+    title: 'Wallets',
+    icon: 'bi bi-wallet2',
+    description: 'Connect wallet accounts used for minting and marketplace operations.',
+    searchFields: ['address', 'chain', 'label'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('user_id', { nullable: true, references: 'user' }),
+      field.string('address', { required: true }),
+      field.string('chain', { required: true }),
+      field.string('label', { nullable: true }),
+    ],
+  },
+  {
+    name: 'NftMintJob',
+    slug: 'nft-mint-job',
+    route: 'nft-mint-jobs',
+    responseKey: 'nftMintJob',
+    title: 'Mint Jobs',
+    icon: 'bi bi-list-check',
+    description: 'Track blockchain mint jobs and transaction state.',
+    searchFields: ['chain', 'status', 'tx_hash'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('nft_item_id', { required: true, references: 'nft_item', onDelete: 'CASCADE' }),
+      field.uuid('nft_wallet_account_id', { nullable: true, references: 'nft_wallet_account' }),
+      field.string('chain', { required: true }),
+      field.enum('status', status.job, { defaultValue: 'queued' }),
+      field.string('tx_hash', { nullable: true }),
+    ],
+  },
+  {
+    name: 'NftMarketplaceListing',
+    slug: 'nft-marketplace-listing',
+    route: 'nft-marketplace-listings',
+    responseKey: 'nftMarketplaceListing',
+    title: 'Marketplace Listings',
+    icon: 'bi bi-shop',
+    description: 'List minted NFT items for sale and track sale lifecycle.',
+    searchFields: ['currency', 'status'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('nft_item_id', { required: true, references: 'nft_item', onDelete: 'CASCADE' }),
+      field.string('price', { required: true }),
+      field.string('currency', { required: true }),
+      field.enum('status', status.listing, { defaultValue: 'draft' }),
+    ],
+  },
+  {
+    name: 'NftRoyaltyProfile',
+    slug: 'nft-royalty-profile',
+    route: 'nft-royalty-profiles',
+    responseKey: 'nftRoyaltyProfile',
+    title: 'Royalty Profiles',
+    icon: 'bi bi-percent',
+    description: 'Manage collection royalty recipients and basis point settings.',
+    searchFields: ['recipient_wallet'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('nft_collection_id', { required: true, references: 'nft_collection', onDelete: 'CASCADE' }),
+      field.string('recipient_wallet', { required: true }),
+      field.number('basis_points', { required: true, integer: true }),
+    ],
+  },
+]
+
+const associations = [
+  { source: 'Org', method: 'hasMany', target: 'NftCollection', options: "{ foreignKey: 'org_id', sourceKey: 'id', as: 'nftCollections' }" },
+  { source: 'NftCollection', method: 'belongsTo', target: 'Org', options: "{ foreignKey: 'org_id', as: 'org' }" },
+  { source: 'Project', method: 'hasMany', target: 'NftCollection', options: "{ foreignKey: 'project_id', sourceKey: 'id', as: 'nftCollections' }" },
+  { source: 'NftCollection', method: 'belongsTo', target: 'Project', options: "{ foreignKey: 'project_id', as: 'project' }" },
+  { source: 'User', method: 'hasMany', target: 'NftCollection', options: "{ foreignKey: 'creator_user_id', sourceKey: 'id', as: 'nftCollections' }" },
+  { source: 'NftCollection', method: 'belongsTo', target: 'User', options: "{ foreignKey: 'creator_user_id', as: 'creator' }" },
+  { source: 'NftCollection', method: 'hasMany', target: 'NftItem', options: "{ foreignKey: 'nft_collection_id', as: 'items', onDelete: 'CASCADE' }" },
+  { source: 'NftItem', method: 'belongsTo', target: 'NftCollection', options: "{ foreignKey: 'nft_collection_id', as: 'collection' }" },
+  { source: 'NftItem', method: 'hasMany', target: 'NftMintJob', options: "{ foreignKey: 'nft_item_id', as: 'mintJobs', onDelete: 'CASCADE' }" },
+  { source: 'NftMintJob', method: 'belongsTo', target: 'NftItem', options: "{ foreignKey: 'nft_item_id', as: 'item' }" },
+  { source: 'NftWalletAccount', method: 'hasMany', target: 'NftMintJob', options: "{ foreignKey: 'nft_wallet_account_id', as: 'mintJobs' }" },
+  { source: 'NftMintJob', method: 'belongsTo', target: 'NftWalletAccount', options: "{ foreignKey: 'nft_wallet_account_id', as: 'walletAccount' }" },
+  { source: 'User', method: 'hasMany', target: 'NftWalletAccount', options: "{ foreignKey: 'user_id', sourceKey: 'id', as: 'nftWalletAccounts' }" },
+  { source: 'NftWalletAccount', method: 'belongsTo', target: 'User', options: "{ foreignKey: 'user_id', as: 'user' }" },
+  { source: 'NftItem', method: 'hasMany', target: 'NftMarketplaceListing', options: "{ foreignKey: 'nft_item_id', as: 'marketplaceListings', onDelete: 'CASCADE' }" },
+  { source: 'NftMarketplaceListing', method: 'belongsTo', target: 'NftItem', options: "{ foreignKey: 'nft_item_id', as: 'item' }" },
+  { source: 'NftCollection', method: 'hasMany', target: 'NftRoyaltyProfile', options: "{ foreignKey: 'nft_collection_id', as: 'royaltyProfiles', onDelete: 'CASCADE' }" },
+  { source: 'NftRoyaltyProfile', method: 'belongsTo', target: 'NftCollection', options: "{ foreignKey: 'nft_collection_id', as: 'collection' }" },
+]
+
+export const nftDefinition = createCrudScaffoldDefinition({
+  title: 'NFT',
+  resources,
+  associations,
+  migrationPrefix: '20260615093',
+  doneMessage: 'NFT scaffold complete.\nRun again with --force to overwrite existing generated files.',
+  namespace: {
+    camel: 'nft',
+    kebab: 'nft',
+    pascal: 'Nft',
+    title: 'NFT',
+  },
+  scope: {
+    resource: 'nft',
+    org: { field: 'org_id' },
+    project: { field: 'project_id', picker: true },
+  },
+  api: {
+    root: 'api/lib/nft',
+    importRoot: '@lib/nft',
+    migrationRoot: 'api/migrations',
+  },
+  src: {
+    root: 'src/nft',
+    importRoot: '@/nft',
+  },
+  store: {
+    apiSliceName: 'nftApiSlice',
+    reducerPath: 'api/nft',
+    insertAfterApiSlice: 'pageApiSlice',
+  },
+  sideNav: {
+    appKey: 'nft',
+    label: 'NFT',
+    title: 'NFT',
+    icon: 'bi bi-gem',
+  },
+  permissions: {
+    appKey: 'nft',
+    label: 'NFT',
+    actions: ['read', 'create', 'update', 'delete'],
+    insertAfterAppKey: 'providers',
+  },
+})
+
+export default nftDefinition

package/scripts/defs/simple-cms-definition.mjs

@@ -0,0 +1,141 @@
+import {
+  createCrudScaffoldDefinition,
+  field,
+} from '../crud-scaffold/src/generator.mjs'
+
+const status = {
+  file: ['draft', 'published'],
+}
+
+const scopedFields = () => [
+  field.uuid('org_id', { nullable: true, references: 'org', skipSchema: true, hideInTable: true }),
+  field.uuid('project_id', { nullable: true, references: 'project', skipSchema: true, hideInTable: true }),
+]
+
+const resources = [
+  {
+    name: 'AppFile',
+    slug: 'app-file',
+    route: 'app-files',
+    responseKey: 'appFile',
+    title: 'Files',
+    icon: 'bi bi-file-earmark-text',
+    description: 'Manage app file content, publishing state, and SEO metadata for existing sites.',
+    searchFields: ['title', 'slug', 'status', 'seo_title'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('site_id', {
+        required: true,
+        references: 'site',
+        onDelete: 'CASCADE',
+        validate: {
+          model: 'Site',
+          importRoot: '@lib/models',
+          message: 'Site Not Found',
+          where: [
+            { column: 'id', value: '$value' },
+            { column: 'org_id', value: 'scopedValues.org_id' },
+          ],
+        },
+      }),
+      field.string('title', { required: true, minLength: 2 }),
+      field.string('slug', { required: true, regex: 'SLUG_REGEX' }),
+      field.enum('status', status.file, { defaultValue: 'draft' }),
+      field.text('content', { nullable: true }),
+      field.string('seo_title', { nullable: true }),
+      field.text('seo_description', { nullable: true }),
+    ],
+  },
+  {
+    name: 'AppFileRevision',
+    slug: 'app-file-revision',
+    route: 'app-file-revisions',
+    responseKey: 'appFileRevision',
+    title: 'File Revisions',
+    icon: 'bi bi-clock-history',
+    description: 'Track saved revisions for app files.',
+    searchFields: ['content'],
+    fields: [
+      ...scopedFields(),
+      field.uuid('app_file_id', {
+        required: true,
+        references: 'app_file',
+        onDelete: 'CASCADE',
+        validate: {
+          model: 'AppFile',
+          message: 'AppFile Not Found',
+          where: [
+            { column: 'id', value: '$value' },
+            { column: 'org_id', value: 'scopedValues.org_id' },
+            { column: 'project_id', value: 'scopedValues.project_id', optional: true },
+          ],
+        },
+      }),
+      field.text('content', { nullable: true }),
+      field.uuid('created_by_user_id', { nullable: true, references: 'user' }),
+    ],
+  },
+]
+
+const associations = [
+  { source: 'Org', method: 'hasMany', target: 'AppFile', options: "{ foreignKey: 'org_id', sourceKey: 'id', as: 'appFiles' }" },
+  { source: 'AppFile', method: 'belongsTo', target: 'Org', options: "{ foreignKey: 'org_id', as: 'org' }" },
+  { source: 'Project', method: 'hasMany', target: 'AppFile', options: "{ foreignKey: 'project_id', sourceKey: 'id', as: 'appFiles' }" },
+  { source: 'AppFile', method: 'belongsTo', target: 'Project', options: "{ foreignKey: 'project_id', as: 'project' }" },
+  { source: 'Site', method: 'hasMany', target: 'AppFile', options: "{ foreignKey: 'site_id', as: 'appFiles', onDelete: 'CASCADE' }" },
+  { source: 'AppFile', method: 'belongsTo', target: 'Site', options: "{ foreignKey: 'site_id', as: 'site' }" },
+  { source: 'AppFile', method: 'hasMany', target: 'AppFileRevision', options: "{ foreignKey: 'app_file_id', as: 'revisions', onDelete: 'CASCADE' }" },
+  { source: 'AppFileRevision', method: 'belongsTo', target: 'AppFile', options: "{ foreignKey: 'app_file_id', as: 'file' }" },
+  { source: 'Org', method: 'hasMany', target: 'AppFileRevision', options: "{ foreignKey: 'org_id', sourceKey: 'id', as: 'appFileRevisions' }" },
+  { source: 'AppFileRevision', method: 'belongsTo', target: 'Org', options: "{ foreignKey: 'org_id', as: 'org' }" },
+  { source: 'Project', method: 'hasMany', target: 'AppFileRevision', options: "{ foreignKey: 'project_id', sourceKey: 'id', as: 'appFileRevisions' }" },
+  { source: 'AppFileRevision', method: 'belongsTo', target: 'Project', options: "{ foreignKey: 'project_id', as: 'project' }" },
+  { source: 'User', method: 'hasMany', target: 'AppFileRevision', options: "{ foreignKey: 'created_by_user_id', sourceKey: 'id', as: 'appFileRevisions' }" },
+  { source: 'AppFileRevision', method: 'belongsTo', target: 'User', options: "{ foreignKey: 'created_by_user_id', as: 'createdBy' }" },
+]
+
+export const simpleCmsDefinition = createCrudScaffoldDefinition({
+  title: 'Simple CMS',
+  resources,
+  associations,
+  migrationPrefix: '20260615096',
+  doneMessage: 'Simple CMS scaffold complete.\nRun again with --force to overwrite existing generated files.',
+  namespace: {
+    camel: 'simpleCms',
+    kebab: 'simple-cms',
+    pascal: 'SimpleCms',
+    title: 'Simple CMS',
+  },
+  scope: {
+    resource: 'simple-cms',
+    org: { field: 'org_id' },
+    project: { field: 'project_id', picker: true },
+  },
+  api: {
+    root: 'api/lib/simple-cms',
+    importRoot: '@lib/simple-cms',
+  },
+  src: {
+    root: 'src/simple-cms',
+    importRoot: '@/simple-cms',
+  },
+  store: {
+    apiSliceName: 'simpleCmsApiSlice',
+    reducerPath: 'api/simpleCms',
+    insertAfterApiSlice: 'pageApiSlice',
+  },
+  sideNav: {
+    appKey: 'simple-cms',
+    label: 'Simple CMS',
+    title: 'Simple CMS',
+    icon: 'bi bi-window-sidebar',
+  },
+  permissions: {
+    appKey: 'simple-cms',
+    label: 'Simple CMS',
+    actions: ['read', 'create', 'update', 'delete'],
+    insertAfterAppKey: 'providers',
+  },
+})
+
+export default simpleCmsDefinition

package/scripts/generate-cms-install-system.mjs

@@ -0,0 +1,4 @@
+import { cmsDefinition } from './defs/cms-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(cmsDefinition)

package/scripts/generate-gallery-system.mjs

@@ -0,0 +1,4 @@
+import { galleryDefinition } from './defs/gallery-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(galleryDefinition)

package/scripts/generate-gpu-marketplace-system.mjs

@@ -0,0 +1,4 @@
+import { gpuDefinition } from './defs/gpu-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(gpuDefinition)

package/scripts/generate-metaverse-system.mjs

@@ -0,0 +1,4 @@
+import { metaverseDefinition } from './defs/metaverse-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(metaverseDefinition)

package/scripts/generate-nft-system.mjs

@@ -0,0 +1,4 @@
+import { nftDefinition } from './defs/nft-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(nftDefinition)

package/scripts/generate-simple-cms-system.mjs

@@ -0,0 +1,4 @@
+import { simpleCmsDefinition } from './defs/simple-cms-definition.mjs'
+import { createGenerator } from './crud-scaffold/src/utils/generator-utils.mjs'
+
+createGenerator(simpleCmsDefinition)

package/scripts/link-core.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const targetRoot = path.resolve(process.cwd(), process.argv[2] || '.')
+const scopeDir = path.join(targetRoot, 'node_modules', '@spacemade')
+const binDir = path.join(targetRoot, 'node_modules', '.bin')
+const legacyCorePath = path.join(scopeDir, 'core')
+
+fs.mkdirSync(scopeDir, { recursive: true })
+fs.mkdirSync(binDir, { recursive: true })
+
+function linkPackage(name, sourcePath) {
+  const linkPath = path.join(scopeDir, name)
+
+  try {
+    const existing = fs.lstatSync(linkPath)
+
+    if (existing.isSymbolicLink()) {
+      fs.rmSync(linkPath)
+    } else {
+      throw new Error(`${linkPath} already exists and is not a symlink`)
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  fs.symlinkSync(sourcePath, linkPath, 'dir')
+  console.log(`linked ${linkPath} -> ${sourcePath}`)
+}
+
+function linkBin() {
+  const binPath = path.join(binDir, 'spacemade')
+
+  try {
+    const existing = fs.lstatSync(binPath)
+
+    if (existing.isSymbolicLink()) {
+      fs.rmSync(binPath)
+    } else {
+      throw new Error(`${binPath} already exists and is not a symlink`)
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  fs.symlinkSync('../@spacemade/ui/scripts/spacemade.mjs', binPath)
+}
+
+linkPackage('ui', packageRoot)
+linkPackage('api', path.join(packageRoot, 'api'))
+linkBin()
+
+try {
+  const existing = fs.lstatSync(legacyCorePath)
+
+  if (existing.isSymbolicLink()) {
+    fs.rmSync(legacyCorePath)
+    console.log(`removed legacy ${legacyCorePath}`)
+  }
+} catch (error) {
+  if (error.code !== 'ENOENT') {
+    throw error
+  }
+}