Files
pages/internal/store/schema_modules.go
T
2026-11-15 05:47:14 +09:00

164 lines
11 KiB
Go

package store
import (
"context"
"fmt"
"strings"
"pageswiki/internal/db"
)
// These definitions adopt known legacy tables without replacing their rows.
// Once released, add a new version; never edit an applied definition.
// Auth, City, tasks and calendars remain in their existing migration paths.
var managedStoreSchemas = map[string][]db.SQLMigration{
"feeds": feedMigrations,
"contacts": contactMigrations,
"task-productivity": taskProductivityMigrations,
"cli-auth": cliAuthMigrations,
"profile-contacts": profileContactMigrations,
"event-jobs": eventJobMigrations,
"projection-metadata": {{Version: 1, Name: "adopt_projection_metadata", Statements: []string{
`CREATE TABLE IF NOT EXISTS projection_metadata (
document_hash TEXT NOT NULL,kind TEXT NOT NULL,version INTEGER NOT NULL,
payload TEXT NOT NULL DEFAULT '{}',error TEXT NOT NULL DEFAULT '',
updated_at_ms INTEGER NOT NULL,retry_at_ms INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY(document_hash,kind,version))`,
`CREATE INDEX IF NOT EXISTS projection_metadata_eviction ON projection_metadata(updated_at_ms DESC)`,
}, Assertions: []string{
schemaColumns("projection_metadata", "document_hash,kind,version,payload,error,updated_at_ms,retry_at_ms"),
schemaUnique("projection_metadata", "document_hash,kind,version"),
schemaIndex("projection_metadata", "projection_metadata_eviction", "updated_at_ms"),
}}},
"resource-history": {{Version: 1, Name: "adopt_resource_history", Statements: []string{
`CREATE TABLE IF NOT EXISTS resource_samples (
id INTEGER PRIMARY KEY, job_uuid TEXT NOT NULL UNIQUE,
timestamp_ms INTEGER NOT NULL, payload TEXT NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_resource_samples_time ON resource_samples(timestamp_ms)`,
}, Assertions: []string{
schemaColumns("resource_samples", "id,job_uuid,timestamp_ms,payload"),
schemaUnique("resource_samples", "job_uuid"),
`SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM pragma_table_info('resource_samples') WHERE name='id' AND type='INTEGER' AND pk=1)`,
schemaIndex("resource_samples", "idx_resource_samples_time", "timestamp_ms"),
}}},
"broadcasts": {{Version: 1, Name: "adopt_broadcasts", Statements: []string{
`CREATE TABLE IF NOT EXISTS broadcasts (uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,title TEXT NOT NULL,body TEXT NOT NULL,severity TEXT NOT NULL DEFAULT 'info' CHECK(severity IN ('info','success','warning','critical')),starts_at_ms INTEGER NOT NULL DEFAULT 0,ends_at_ms INTEGER NOT NULL DEFAULT 0,created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_broadcast_active ON broadcasts(domain_uuid,starts_at_ms,ends_at_ms,updated_at_ms DESC)`,
}, Assertions: []string{
schemaColumns("broadcasts", "uuid,domain_uuid,title,body,severity,starts_at_ms,ends_at_ms,created_at_ms,updated_at_ms"),
schemaUnique("broadcasts", "uuid"),
schemaIndex("broadcasts", "idx_broadcast_active", "domain_uuid,starts_at_ms,ends_at_ms,updated_at_ms"),
}}},
"browser-navigation": {{Version: 1, Name: "adopt_browser_navigation", Statements: []string{
`CREATE TABLE IF NOT EXISTS browser_navigation_links (
uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,principal_uuid TEXT NOT NULL,
label TEXT NOT NULL,path TEXT NOT NULL,is_directory INTEGER NOT NULL DEFAULT 0,
position INTEGER NOT NULL DEFAULT 0,created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,
UNIQUE(domain_uuid, principal_uuid, path))`,
`CREATE INDEX IF NOT EXISTS idx_browser_navigation_owner ON browser_navigation_links(domain_uuid, principal_uuid, position, created_at_ms)`,
}, AddColumns: []db.SQLiteColumn{{Table: "browser_navigation_links", Name: "is_directory", Declaration: "INTEGER NOT NULL DEFAULT 0"}}, Assertions: []string{
schemaColumns("browser_navigation_links", "uuid,domain_uuid,principal_uuid,label,path,is_directory,position,created_at_ms,updated_at_ms"),
schemaUnique("browser_navigation_links", "uuid"),
schemaUnique("browser_navigation_links", "domain_uuid,principal_uuid,path"),
schemaAddedColumn("browser_navigation_links", "is_directory", "INTEGER", "0"),
schemaIndex("browser_navigation_links", "idx_browser_navigation_owner", "domain_uuid,principal_uuid,position,created_at_ms"),
}}},
"adapter-sessions": {{Version: 1, Name: "adopt_adapter_sessions", Statements: []string{
`CREATE TABLE IF NOT EXISTS adapter_sessions (
ticket_hash TEXT PRIMARY KEY,session_hash TEXT NOT NULL DEFAULT '',
domain_uuid TEXT NOT NULL,plugin_id TEXT NOT NULL,object_uuid TEXT NOT NULL,
principal_uuid TEXT NOT NULL DEFAULT '',base_revision_uuid TEXT NOT NULL,
ticket_expires_at_ms INTEGER NOT NULL,session_expires_at_ms INTEGER NOT NULL DEFAULT 0,
exchanged_at_ms INTEGER NOT NULL DEFAULT 0,created_at_ms INTEGER NOT NULL)`,
`CREATE UNIQUE INDEX IF NOT EXISTS idx_adapter_session_hash ON adapter_sessions(session_hash) WHERE session_hash != ''`,
}, AddColumns: []db.SQLiteColumn{
{Table: "adapter_sessions", Name: "root_path", Declaration: "TEXT NOT NULL DEFAULT ''"},
{Table: "adapter_sessions", Name: "principal_uuid", Declaration: "TEXT NOT NULL DEFAULT ''"},
}, Assertions: []string{
schemaColumns("adapter_sessions", "ticket_hash,session_hash,domain_uuid,plugin_id,object_uuid,principal_uuid,base_revision_uuid,ticket_expires_at_ms,session_expires_at_ms,exchanged_at_ms,created_at_ms,root_path"),
schemaUnique("adapter_sessions", "ticket_hash"),
schemaAddedColumn("adapter_sessions", "root_path", "TEXT", "''"),
schemaAddedColumn("adapter_sessions", "principal_uuid", "TEXT", "''"),
schemaIndex("adapter_sessions", "idx_adapter_session_hash", "session_hash"),
`SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM pragma_index_list('adapter_sessions') WHERE name='idx_adapter_session_hash' AND "unique"=1 AND partial=1)`,
schemaIndexPredicate("idx_adapter_session_hash", "session_hash != ''"),
}}},
"imports": {{Version: 1, Name: "adopt_imports", Statements: []string{
`CREATE TABLE IF NOT EXISTS import_sessions(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,actor_uuid TEXT NOT NULL DEFAULT '',archive_name TEXT NOT NULL,archive_path TEXT NOT NULL,target_prefix TEXT NOT NULL DEFAULT '/',status TEXT NOT NULL DEFAULT 'queued',total_files INTEGER NOT NULL DEFAULT 0,markdown_files INTEGER NOT NULL DEFAULT 0,error TEXT NOT NULL DEFAULT '',created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL)`,
`CREATE TABLE IF NOT EXISTS import_items(session_uuid TEXT NOT NULL,sequence INTEGER NOT NULL,source_path TEXT NOT NULL,target_path TEXT NOT NULL,size INTEGER NOT NULL DEFAULT 0,content_type TEXT NOT NULL DEFAULT '',title TEXT NOT NULL DEFAULT '',suggested_quartier TEXT NOT NULL DEFAULT '',suggested_street TEXT NOT NULL DEFAULT '',suggested_spot TEXT NOT NULL DEFAULT '',confidence REAL NOT NULL DEFAULT 0,selected INTEGER NOT NULL DEFAULT 1,PRIMARY KEY(session_uuid,sequence))`,
`CREATE TABLE IF NOT EXISTS import_journal(session_uuid TEXT NOT NULL,sequence INTEGER NOT NULL,path TEXT NOT NULL,object_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(session_uuid,sequence))`,
`CREATE TABLE IF NOT EXISTS import_city_journal(session_uuid TEXT NOT NULL,kind TEXT NOT NULL,node_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(session_uuid,kind,node_uuid))`,
`CREATE TABLE IF NOT EXISTS import_city_edges(session_uuid TEXT NOT NULL,spot_uuid TEXT NOT NULL,page_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(session_uuid,spot_uuid,page_uuid))`,
`CREATE INDEX IF NOT EXISTS idx_import_sessions_domain ON import_sessions(domain_uuid,created_at_ms DESC)`,
}, AddColumns: []db.SQLiteColumn{{Table: "import_journal", Name: "completed", Declaration: "INTEGER NOT NULL DEFAULT 0"}}, Assertions: []string{
schemaColumns("import_sessions", "uuid,domain_uuid,actor_uuid,archive_name,archive_path,target_prefix,status,total_files,markdown_files,error,created_at_ms,updated_at_ms"),
schemaColumns("import_items", "session_uuid,sequence,source_path,target_path,size,content_type,title,suggested_quartier,suggested_street,suggested_spot,confidence,selected"),
schemaColumns("import_journal", "session_uuid,sequence,path,object_uuid,created_at_ms,completed"),
schemaColumns("import_city_journal", "session_uuid,kind,node_uuid,created_at_ms"),
schemaColumns("import_city_edges", "session_uuid,spot_uuid,page_uuid,created_at_ms"),
schemaUnique("import_sessions", "uuid"),
schemaUnique("import_items", "session_uuid,sequence"),
schemaUnique("import_journal", "session_uuid,sequence"),
schemaUnique("import_city_journal", "session_uuid,kind,node_uuid"),
schemaUnique("import_city_edges", "session_uuid,spot_uuid,page_uuid"),
schemaAddedColumn("import_journal", "completed", "INTEGER", "0"),
schemaIndex("import_sessions", "idx_import_sessions_domain", "domain_uuid,created_at_ms"),
}}},
}
func (s *Store) ensureSchemaComponent(component string) error {
if s.ReadOnly {
return ErrReadOnly
}
if s.sqlBackend == storePostgreSQL {
switch component {
case "projection-metadata", "resource-history", "broadcasts", "adapter-sessions":
return s.ensurePostgreSQLServiceMetadata(context.Background(), component)
case "event-jobs":
return s.ensurePostgreSQLEventJobs(context.Background())
case "feeds":
return s.ensurePostgreSQLFeeds(context.Background())
case "contacts":
return s.ensurePostgreSQLContacts(context.Background())
case "profile-contacts":
return s.ensurePostgreSQLProfileContacts(context.Background())
case "cli-auth":
return s.ensurePostgreSQLAuthFoundation(context.Background())
default:
return fmt.Errorf("%w: %s", ErrPostgreSQLComponentNotReady, component)
}
}
steps, ok := managedStoreSchemas[component]
if !ok {
return fmt.Errorf("unknown schema component %q", component)
}
return db.ApplySQLiteMigrations(context.Background(), s.DB, component, steps)
}
// These helpers consume only static definitions above, never request input.
func schemaColumns(table, columns string) string {
return fmt.Sprintf("SELECT %s FROM %q LIMIT 0", columns, table)
}
func schemaUnique(table, columns string) string {
return fmt.Sprintf(`SELECT 1 WHERE NOT EXISTS (
SELECT 1 FROM pragma_index_list('%s') AS i WHERE i."unique"=1 AND i.partial=0
AND (SELECT group_concat(name,',') FROM (SELECT name FROM pragma_index_info(i.name) ORDER BY seqno))='%s')`, table, columns)
}
func schemaIndex(table, name, columns string) string {
return fmt.Sprintf(`SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM pragma_index_list('%s') WHERE name='%s')
OR (SELECT group_concat(name,',') FROM (SELECT name FROM pragma_index_info('%s') ORDER BY seqno)) IS NOT '%s'`, table, name, name, strings.TrimSpace(columns))
}
func schemaAddedColumn(table, column, kind, defaultSQL string) string {
return fmt.Sprintf(`SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM pragma_table_info('%s') WHERE name='%s' AND upper(type)='%s' AND "notnull"=1 AND dflt_value='%s')`, table, column, kind, strings.ReplaceAll(defaultSQL, "'", "''"))
}
func schemaIndexPredicate(name, predicate string) string {
normalized := strings.ToLower(strings.Join(strings.Fields(predicate), ""))
return fmt.Sprintf(`SELECT 1 WHERE NOT EXISTS (
SELECT 1 FROM (SELECT lower(replace(replace(replace(replace(sql,' ',''),char(9),''),char(10),''),char(13),'')) AS normalized FROM sqlite_master WHERE type='index' AND name='%s')
WHERE substr(normalized,instr(normalized,'where')+5)='%s')`, name, strings.ReplaceAll(normalized, "'", "''"))
}